compute

package
v2.19.0 Latest Latest
Warning

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

 Go to latest Published: Apr 12, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AggregateV2 added in v2.11.0 

type AggregateV2 struct {
	pulumi.CustomResourceState

	// The list of hosts contained in the Host Aggregate. The hosts must be added
	// to Openstack and visible in the web interface, or the provider will fail to add them to the host
	// aggregate.
	Hosts pulumi.StringArrayOutput `pulumi:"hosts"`
	// The metadata of the Host Aggregate. Can be useful to indicate scheduler hints.
	Metadata pulumi.StringMapOutput `pulumi:"metadata"`
	// The name of the Host Aggregate
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the Availability Zone to use. If ommited, it will take the default
	// availability zone.
	Zone pulumi.StringPtrOutput `pulumi:"zone"`
}

Manages a Host Aggregate within Openstack Nova.

## Example Usage ### Full example

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewAggregateV2(ctx, "dellServers", &compute.AggregateV2Args{
			Hosts: pulumi.StringArray{
				pulumi.String("myhost01.example.com"),
				pulumi.String("myhost02.example.com"),
			},
			Metadata: pulumi.StringMap{
				"cpus": pulumi.String("56"),
			},
			Zone: pulumi.String("nova"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Minimum required example

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewAggregateV2(ctx, "test", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

You can import an existing Host Aggregate by their ID.

```sh 

$ pulumi import openstack:compute/aggregateV2:AggregateV2 myaggregate 24

``` 

The ID can be obtained with an openstack command$ openstack aggregate list +----+------+-------------------+ | ID | Name | Availability Zone | +----+------+-------------------+ | 59 | test | None

| +----+------+-------------------+

func GetAggregateV2 added in v2.11.0 

func GetAggregateV2(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AggregateV2State, opts ...pulumi.ResourceOption) (*AggregateV2, error)

GetAggregateV2 gets an existing AggregateV2 resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAggregateV2 added in v2.11.0 

func NewAggregateV2(ctx *pulumi.Context,
	name string, args *AggregateV2Args, opts ...pulumi.ResourceOption) (*AggregateV2, error)

NewAggregateV2 registers a new resource with the given unique name, arguments, and options.

func (*AggregateV2) ElementType added in v2.11.0 

func (*AggregateV2) ElementType() reflect.Type

func (*AggregateV2) ToAggregateV2Output added in v2.11.0 

func (i *AggregateV2) ToAggregateV2Output() AggregateV2Output

func (*AggregateV2) ToAggregateV2OutputWithContext added in v2.11.0 

func (i *AggregateV2) ToAggregateV2OutputWithContext(ctx context.Context) AggregateV2Output

func (*AggregateV2) ToAggregateV2PtrOutput added in v2.14.1 

func (i *AggregateV2) ToAggregateV2PtrOutput() AggregateV2PtrOutput

func (*AggregateV2) ToAggregateV2PtrOutputWithContext added in v2.14.1 

func (i *AggregateV2) ToAggregateV2PtrOutputWithContext(ctx context.Context) AggregateV2PtrOutput

type AggregateV2Args added in v2.11.0 

type AggregateV2Args struct {
	// The list of hosts contained in the Host Aggregate. The hosts must be added
	// to Openstack and visible in the web interface, or the provider will fail to add them to the host
	// aggregate.
	Hosts pulumi.StringArrayInput
	// The metadata of the Host Aggregate. Can be useful to indicate scheduler hints.
	Metadata pulumi.StringMapInput
	// The name of the Host Aggregate
	Name pulumi.StringPtrInput
	// The name of the Availability Zone to use. If ommited, it will take the default
	// availability zone.
	Zone pulumi.StringPtrInput
}

The set of arguments for constructing a AggregateV2 resource.

func (AggregateV2Args) ElementType added in v2.11.0 

func (AggregateV2Args) ElementType() reflect.Type

type AggregateV2Array added in v2.14.1 

type AggregateV2Array []AggregateV2Input

func (AggregateV2Array) ElementType added in v2.14.1 

func (AggregateV2Array) ElementType() reflect.Type

func (AggregateV2Array) ToAggregateV2ArrayOutput added in v2.14.1 

func (i AggregateV2Array) ToAggregateV2ArrayOutput() AggregateV2ArrayOutput

func (AggregateV2Array) ToAggregateV2ArrayOutputWithContext added in v2.14.1 

func (i AggregateV2Array) ToAggregateV2ArrayOutputWithContext(ctx context.Context) AggregateV2ArrayOutput

type AggregateV2ArrayInput added in v2.14.1 

type AggregateV2ArrayInput interface {
	pulumi.Input

	ToAggregateV2ArrayOutput() AggregateV2ArrayOutput
	ToAggregateV2ArrayOutputWithContext(context.Context) AggregateV2ArrayOutput
}

AggregateV2ArrayInput is an input type that accepts AggregateV2Array and AggregateV2ArrayOutput values. You can construct a concrete instance of `AggregateV2ArrayInput` via: 

AggregateV2Array{ AggregateV2Args{...} }

type AggregateV2ArrayOutput added in v2.14.1 

type AggregateV2ArrayOutput struct{ *pulumi.OutputState }

func (AggregateV2ArrayOutput) ElementType added in v2.14.1 

func (AggregateV2ArrayOutput) ElementType() reflect.Type

func (AggregateV2ArrayOutput) Index added in v2.14.1 

func (o AggregateV2ArrayOutput) Index(i pulumi.IntInput) AggregateV2Output

func (AggregateV2ArrayOutput) ToAggregateV2ArrayOutput added in v2.14.1 

func (o AggregateV2ArrayOutput) ToAggregateV2ArrayOutput() AggregateV2ArrayOutput

func (AggregateV2ArrayOutput) ToAggregateV2ArrayOutputWithContext added in v2.14.1 

func (o AggregateV2ArrayOutput) ToAggregateV2ArrayOutputWithContext(ctx context.Context) AggregateV2ArrayOutput

type AggregateV2Input added in v2.11.0 

type AggregateV2Input interface {
	pulumi.Input

	ToAggregateV2Output() AggregateV2Output
	ToAggregateV2OutputWithContext(ctx context.Context) AggregateV2Output
}

type AggregateV2Map added in v2.14.1 

type AggregateV2Map map[string]AggregateV2Input

func (AggregateV2Map) ElementType added in v2.14.1 

func (AggregateV2Map) ElementType() reflect.Type

func (AggregateV2Map) ToAggregateV2MapOutput added in v2.14.1 

func (i AggregateV2Map) ToAggregateV2MapOutput() AggregateV2MapOutput

func (AggregateV2Map) ToAggregateV2MapOutputWithContext added in v2.14.1 

func (i AggregateV2Map) ToAggregateV2MapOutputWithContext(ctx context.Context) AggregateV2MapOutput

type AggregateV2MapInput added in v2.14.1 

type AggregateV2MapInput interface {
	pulumi.Input

	ToAggregateV2MapOutput() AggregateV2MapOutput
	ToAggregateV2MapOutputWithContext(context.Context) AggregateV2MapOutput
}

AggregateV2MapInput is an input type that accepts AggregateV2Map and AggregateV2MapOutput values. You can construct a concrete instance of `AggregateV2MapInput` via: 

AggregateV2Map{ "key": AggregateV2Args{...} }

type AggregateV2MapOutput added in v2.14.1 

type AggregateV2MapOutput struct{ *pulumi.OutputState }

func (AggregateV2MapOutput) ElementType added in v2.14.1 

func (AggregateV2MapOutput) ElementType() reflect.Type

func (AggregateV2MapOutput) MapIndex added in v2.14.1 

func (o AggregateV2MapOutput) MapIndex(k pulumi.StringInput) AggregateV2Output

func (AggregateV2MapOutput) ToAggregateV2MapOutput added in v2.14.1 

func (o AggregateV2MapOutput) ToAggregateV2MapOutput() AggregateV2MapOutput

func (AggregateV2MapOutput) ToAggregateV2MapOutputWithContext added in v2.14.1 

func (o AggregateV2MapOutput) ToAggregateV2MapOutputWithContext(ctx context.Context) AggregateV2MapOutput

type AggregateV2Output added in v2.11.0 

type AggregateV2Output struct {
	*pulumi.OutputState
}

func (AggregateV2Output) ElementType added in v2.11.0 

func (AggregateV2Output) ElementType() reflect.Type

func (AggregateV2Output) ToAggregateV2Output added in v2.11.0 

func (o AggregateV2Output) ToAggregateV2Output() AggregateV2Output

func (AggregateV2Output) ToAggregateV2OutputWithContext added in v2.11.0 

func (o AggregateV2Output) ToAggregateV2OutputWithContext(ctx context.Context) AggregateV2Output

func (AggregateV2Output) ToAggregateV2PtrOutput added in v2.14.1 

func (o AggregateV2Output) ToAggregateV2PtrOutput() AggregateV2PtrOutput

func (AggregateV2Output) ToAggregateV2PtrOutputWithContext added in v2.14.1 

func (o AggregateV2Output) ToAggregateV2PtrOutputWithContext(ctx context.Context) AggregateV2PtrOutput

type AggregateV2PtrInput added in v2.14.1 

type AggregateV2PtrInput interface {
	pulumi.Input

	ToAggregateV2PtrOutput() AggregateV2PtrOutput
	ToAggregateV2PtrOutputWithContext(ctx context.Context) AggregateV2PtrOutput
}

type AggregateV2PtrOutput added in v2.14.1 

type AggregateV2PtrOutput struct {
	*pulumi.OutputState
}

func (AggregateV2PtrOutput) ElementType added in v2.14.1 

func (AggregateV2PtrOutput) ElementType() reflect.Type

func (AggregateV2PtrOutput) ToAggregateV2PtrOutput added in v2.14.1 

func (o AggregateV2PtrOutput) ToAggregateV2PtrOutput() AggregateV2PtrOutput

func (AggregateV2PtrOutput) ToAggregateV2PtrOutputWithContext added in v2.14.1 

func (o AggregateV2PtrOutput) ToAggregateV2PtrOutputWithContext(ctx context.Context) AggregateV2PtrOutput

type AggregateV2State added in v2.11.0 

type AggregateV2State struct {
	// The list of hosts contained in the Host Aggregate. The hosts must be added
	// to Openstack and visible in the web interface, or the provider will fail to add them to the host
	// aggregate.
	Hosts pulumi.StringArrayInput
	// The metadata of the Host Aggregate. Can be useful to indicate scheduler hints.
	Metadata pulumi.StringMapInput
	// The name of the Host Aggregate
	Name pulumi.StringPtrInput
	// The name of the Availability Zone to use. If ommited, it will take the default
	// availability zone.
	Zone pulumi.StringPtrInput
}

func (AggregateV2State) ElementType added in v2.11.0 

func (AggregateV2State) ElementType() reflect.Type

type Flavor 

type Flavor struct {
	pulumi.CustomResourceState

	// The amount of disk space in GiB to use for the root
	// (/) partition. Changing this creates a new flavor.
	Disk pulumi.IntOutput `pulumi:"disk"`
	// The amount of ephemeral in GiB. If unspecified,
	// the default is 0. Changing this creates a new flavor.
	Ephemeral pulumi.IntPtrOutput `pulumi:"ephemeral"`
	// Key/Value pairs of metadata for the flavor.
	ExtraSpecs pulumi.MapOutput `pulumi:"extraSpecs"`
	// Unique ID (integer or UUID) of flavor to create. Changing
	// this creates a new flavor.
	FlavorId pulumi.StringOutput `pulumi:"flavorId"`
	// Whether the flavor is public. Changing this creates
	// a new flavor.
	IsPublic pulumi.BoolPtrOutput `pulumi:"isPublic"`
	// A unique name for the flavor. Changing this creates a new
	// flavor.
	Name pulumi.StringOutput `pulumi:"name"`
	// The amount of RAM to use, in megabytes. Changing this
	// creates a new flavor.
	Ram pulumi.IntOutput `pulumi:"ram"`
	// The region in which to obtain the V2 Compute client.
	// Flavors are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new flavor.
	Region pulumi.StringOutput `pulumi:"region"`
	// RX/TX bandwith factor. The default is 1. Changing
	// this creates a new flavor.
	RxTxFactor pulumi.Float64PtrOutput `pulumi:"rxTxFactor"`
	// The amount of disk space in megabytes to use. If
	// unspecified, the default is 0. Changing this creates a new flavor.
	Swap pulumi.IntPtrOutput `pulumi:"swap"`
	// The number of virtual CPUs to use. Changing this creates
	// a new flavor.
	Vcpus pulumi.IntOutput `pulumi:"vcpus"`
}

Manages a V2 flavor resource within OpenStack.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewFlavor(ctx, "test_flavor", &compute.FlavorArgs{
			Disk: pulumi.Int(20),
			ExtraSpecs: pulumi.StringMap{
				"hw:cpu_policy":        pulumi.String("CPU-POLICY"),
				"hw:cpu_thread_policy": pulumi.String("CPU-THREAD-POLICY"),
			},
			Ram:   pulumi.Int(8096),
			Vcpus: pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Flavors can be imported using the `ID`, e.g.

```sh 

$ pulumi import openstack:compute/flavor:Flavor my-flavor 4142e64b-1b35-44a0-9b1e-5affc7af1106

```

func GetFlavor 

func GetFlavor(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FlavorState, opts ...pulumi.ResourceOption) (*Flavor, error)

GetFlavor gets an existing Flavor resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFlavor 

func NewFlavor(ctx *pulumi.Context,
	name string, args *FlavorArgs, opts ...pulumi.ResourceOption) (*Flavor, error)

NewFlavor registers a new resource with the given unique name, arguments, and options.

func (*Flavor) ElementType added in v2.10.0 

func (*Flavor) ElementType() reflect.Type

func (*Flavor) ToFlavorOutput added in v2.10.0 

func (i *Flavor) ToFlavorOutput() FlavorOutput

func (*Flavor) ToFlavorOutputWithContext added in v2.10.0 

func (i *Flavor) ToFlavorOutputWithContext(ctx context.Context) FlavorOutput

func (*Flavor) ToFlavorPtrOutput added in v2.14.1 

func (i *Flavor) ToFlavorPtrOutput() FlavorPtrOutput

func (*Flavor) ToFlavorPtrOutputWithContext added in v2.14.1 

func (i *Flavor) ToFlavorPtrOutputWithContext(ctx context.Context) FlavorPtrOutput

type FlavorAccess 

type FlavorAccess struct {
	pulumi.CustomResourceState

	// The UUID of flavor to use. Changing this creates a new flavor access.
	FlavorId pulumi.StringOutput `pulumi:"flavorId"`
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used.
	// Changing this creates a new flavor access.
	Region pulumi.StringOutput `pulumi:"region"`
	// The UUID of tenant which is allowed to use the flavor.
	// Changing this creates a new flavor access.
	TenantId pulumi.StringOutput `pulumi:"tenantId"`
}

Manages a project access for flavor V2 resource within OpenStack.

> **Note:** You _must_ have admin privileges in your OpenStack cloud to use this resource.

***

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/identity"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project1, err := identity.NewProject(ctx, "project1", nil)
		if err != nil {
			return err
		}
		flavor1, err := compute.NewFlavor(ctx, "flavor1", &compute.FlavorArgs{
			Disk:     pulumi.Int(20),
			IsPublic: pulumi.Bool(false),
			Ram:      pulumi.Int(8096),
			Vcpus:    pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewFlavorAccess(ctx, "access1", &compute.FlavorAccessArgs{
			FlavorId: flavor1.ID(),
			TenantId: project1.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

This resource can be imported by specifying all two arguments, separated by a forward slash

```sh 

$ pulumi import openstack:compute/flavorAccess:FlavorAccess access_1 <flavor_id>/<tenant_id>

```

func GetFlavorAccess 

func GetFlavorAccess(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FlavorAccessState, opts ...pulumi.ResourceOption) (*FlavorAccess, error)

GetFlavorAccess gets an existing FlavorAccess resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFlavorAccess 

func NewFlavorAccess(ctx *pulumi.Context,
	name string, args *FlavorAccessArgs, opts ...pulumi.ResourceOption) (*FlavorAccess, error)

NewFlavorAccess registers a new resource with the given unique name, arguments, and options.

func (*FlavorAccess) ElementType added in v2.10.0 

func (*FlavorAccess) ElementType() reflect.Type

func (*FlavorAccess) ToFlavorAccessOutput added in v2.10.0 

func (i *FlavorAccess) ToFlavorAccessOutput() FlavorAccessOutput

func (*FlavorAccess) ToFlavorAccessOutputWithContext added in v2.10.0 

func (i *FlavorAccess) ToFlavorAccessOutputWithContext(ctx context.Context) FlavorAccessOutput

func (*FlavorAccess) ToFlavorAccessPtrOutput added in v2.14.1 

func (i *FlavorAccess) ToFlavorAccessPtrOutput() FlavorAccessPtrOutput

func (*FlavorAccess) ToFlavorAccessPtrOutputWithContext added in v2.14.1 

func (i *FlavorAccess) ToFlavorAccessPtrOutputWithContext(ctx context.Context) FlavorAccessPtrOutput

type FlavorAccessArgs 

type FlavorAccessArgs struct {
	// The UUID of flavor to use. Changing this creates a new flavor access.
	FlavorId pulumi.StringInput
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used.
	// Changing this creates a new flavor access.
	Region pulumi.StringPtrInput
	// The UUID of tenant which is allowed to use the flavor.
	// Changing this creates a new flavor access.
	TenantId pulumi.StringInput
}

The set of arguments for constructing a FlavorAccess resource.

func (FlavorAccessArgs) ElementType 

func (FlavorAccessArgs) ElementType() reflect.Type

type FlavorAccessArray added in v2.14.1 

type FlavorAccessArray []FlavorAccessInput

func (FlavorAccessArray) ElementType added in v2.14.1 

func (FlavorAccessArray) ElementType() reflect.Type

func (FlavorAccessArray) ToFlavorAccessArrayOutput added in v2.14.1 

func (i FlavorAccessArray) ToFlavorAccessArrayOutput() FlavorAccessArrayOutput

func (FlavorAccessArray) ToFlavorAccessArrayOutputWithContext added in v2.14.1 

func (i FlavorAccessArray) ToFlavorAccessArrayOutputWithContext(ctx context.Context) FlavorAccessArrayOutput

type FlavorAccessArrayInput added in v2.14.1 

type FlavorAccessArrayInput interface {
	pulumi.Input

	ToFlavorAccessArrayOutput() FlavorAccessArrayOutput
	ToFlavorAccessArrayOutputWithContext(context.Context) FlavorAccessArrayOutput
}

FlavorAccessArrayInput is an input type that accepts FlavorAccessArray and FlavorAccessArrayOutput values. You can construct a concrete instance of `FlavorAccessArrayInput` via: 

FlavorAccessArray{ FlavorAccessArgs{...} }

type FlavorAccessArrayOutput added in v2.14.1 

type FlavorAccessArrayOutput struct{ *pulumi.OutputState }

func (FlavorAccessArrayOutput) ElementType added in v2.14.1 

func (FlavorAccessArrayOutput) ElementType() reflect.Type

func (FlavorAccessArrayOutput) Index added in v2.14.1 

func (o FlavorAccessArrayOutput) Index(i pulumi.IntInput) FlavorAccessOutput

func (FlavorAccessArrayOutput) ToFlavorAccessArrayOutput added in v2.14.1 

func (o FlavorAccessArrayOutput) ToFlavorAccessArrayOutput() FlavorAccessArrayOutput

func (FlavorAccessArrayOutput) ToFlavorAccessArrayOutputWithContext added in v2.14.1 

func (o FlavorAccessArrayOutput) ToFlavorAccessArrayOutputWithContext(ctx context.Context) FlavorAccessArrayOutput

type FlavorAccessInput added in v2.10.0 

type FlavorAccessInput interface {
	pulumi.Input

	ToFlavorAccessOutput() FlavorAccessOutput
	ToFlavorAccessOutputWithContext(ctx context.Context) FlavorAccessOutput
}

type FlavorAccessMap added in v2.14.1 

type FlavorAccessMap map[string]FlavorAccessInput

func (FlavorAccessMap) ElementType added in v2.14.1 

func (FlavorAccessMap) ElementType() reflect.Type

func (FlavorAccessMap) ToFlavorAccessMapOutput added in v2.14.1 

func (i FlavorAccessMap) ToFlavorAccessMapOutput() FlavorAccessMapOutput

func (FlavorAccessMap) ToFlavorAccessMapOutputWithContext added in v2.14.1 

func (i FlavorAccessMap) ToFlavorAccessMapOutputWithContext(ctx context.Context) FlavorAccessMapOutput

type FlavorAccessMapInput added in v2.14.1 

type FlavorAccessMapInput interface {
	pulumi.Input

	ToFlavorAccessMapOutput() FlavorAccessMapOutput
	ToFlavorAccessMapOutputWithContext(context.Context) FlavorAccessMapOutput
}

FlavorAccessMapInput is an input type that accepts FlavorAccessMap and FlavorAccessMapOutput values. You can construct a concrete instance of `FlavorAccessMapInput` via: 

FlavorAccessMap{ "key": FlavorAccessArgs{...} }

type FlavorAccessMapOutput added in v2.14.1 

type FlavorAccessMapOutput struct{ *pulumi.OutputState }

func (FlavorAccessMapOutput) ElementType added in v2.14.1 

func (FlavorAccessMapOutput) ElementType() reflect.Type

func (FlavorAccessMapOutput) MapIndex added in v2.14.1 

func (o FlavorAccessMapOutput) MapIndex(k pulumi.StringInput) FlavorAccessOutput

func (FlavorAccessMapOutput) ToFlavorAccessMapOutput added in v2.14.1 

func (o FlavorAccessMapOutput) ToFlavorAccessMapOutput() FlavorAccessMapOutput

func (FlavorAccessMapOutput) ToFlavorAccessMapOutputWithContext added in v2.14.1 

func (o FlavorAccessMapOutput) ToFlavorAccessMapOutputWithContext(ctx context.Context) FlavorAccessMapOutput

type FlavorAccessOutput added in v2.10.0 

type FlavorAccessOutput struct {
	*pulumi.OutputState
}

func (FlavorAccessOutput) ElementType added in v2.10.0 

func (FlavorAccessOutput) ElementType() reflect.Type

func (FlavorAccessOutput) ToFlavorAccessOutput added in v2.10.0 

func (o FlavorAccessOutput) ToFlavorAccessOutput() FlavorAccessOutput

func (FlavorAccessOutput) ToFlavorAccessOutputWithContext added in v2.10.0 

func (o FlavorAccessOutput) ToFlavorAccessOutputWithContext(ctx context.Context) FlavorAccessOutput

func (FlavorAccessOutput) ToFlavorAccessPtrOutput added in v2.14.1 

func (o FlavorAccessOutput) ToFlavorAccessPtrOutput() FlavorAccessPtrOutput

func (FlavorAccessOutput) ToFlavorAccessPtrOutputWithContext added in v2.14.1 

func (o FlavorAccessOutput) ToFlavorAccessPtrOutputWithContext(ctx context.Context) FlavorAccessPtrOutput

type FlavorAccessPtrInput added in v2.14.1 

type FlavorAccessPtrInput interface {
	pulumi.Input

	ToFlavorAccessPtrOutput() FlavorAccessPtrOutput
	ToFlavorAccessPtrOutputWithContext(ctx context.Context) FlavorAccessPtrOutput
}

type FlavorAccessPtrOutput added in v2.14.1 

type FlavorAccessPtrOutput struct {
	*pulumi.OutputState
}

func (FlavorAccessPtrOutput) ElementType added in v2.14.1 

func (FlavorAccessPtrOutput) ElementType() reflect.Type

func (FlavorAccessPtrOutput) ToFlavorAccessPtrOutput added in v2.14.1 

func (o FlavorAccessPtrOutput) ToFlavorAccessPtrOutput() FlavorAccessPtrOutput

func (FlavorAccessPtrOutput) ToFlavorAccessPtrOutputWithContext added in v2.14.1 

func (o FlavorAccessPtrOutput) ToFlavorAccessPtrOutputWithContext(ctx context.Context) FlavorAccessPtrOutput

type FlavorAccessState 

type FlavorAccessState struct {
	// The UUID of flavor to use. Changing this creates a new flavor access.
	FlavorId pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used.
	// Changing this creates a new flavor access.
	Region pulumi.StringPtrInput
	// The UUID of tenant which is allowed to use the flavor.
	// Changing this creates a new flavor access.
	TenantId pulumi.StringPtrInput
}

func (FlavorAccessState) ElementType 

func (FlavorAccessState) ElementType() reflect.Type

type FlavorArgs 

type FlavorArgs struct {
	// The amount of disk space in GiB to use for the root
	// (/) partition. Changing this creates a new flavor.
	Disk pulumi.IntInput
	// The amount of ephemeral in GiB. If unspecified,
	// the default is 0. Changing this creates a new flavor.
	Ephemeral pulumi.IntPtrInput
	// Key/Value pairs of metadata for the flavor.
	ExtraSpecs pulumi.MapInput
	// Unique ID (integer or UUID) of flavor to create. Changing
	// this creates a new flavor.
	FlavorId pulumi.StringPtrInput
	// Whether the flavor is public. Changing this creates
	// a new flavor.
	IsPublic pulumi.BoolPtrInput
	// A unique name for the flavor. Changing this creates a new
	// flavor.
	Name pulumi.StringPtrInput
	// The amount of RAM to use, in megabytes. Changing this
	// creates a new flavor.
	Ram pulumi.IntInput
	// The region in which to obtain the V2 Compute client.
	// Flavors are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new flavor.
	Region pulumi.StringPtrInput
	// RX/TX bandwith factor. The default is 1. Changing
	// this creates a new flavor.
	RxTxFactor pulumi.Float64PtrInput
	// The amount of disk space in megabytes to use. If
	// unspecified, the default is 0. Changing this creates a new flavor.
	Swap pulumi.IntPtrInput
	// The number of virtual CPUs to use. Changing this creates
	// a new flavor.
	Vcpus pulumi.IntInput
}

The set of arguments for constructing a Flavor resource.

func (FlavorArgs) ElementType 

func (FlavorArgs) ElementType() reflect.Type

type FlavorArray added in v2.14.1 

type FlavorArray []FlavorInput

func (FlavorArray) ElementType added in v2.14.1 

func (FlavorArray) ElementType() reflect.Type

func (FlavorArray) ToFlavorArrayOutput added in v2.14.1 

func (i FlavorArray) ToFlavorArrayOutput() FlavorArrayOutput

func (FlavorArray) ToFlavorArrayOutputWithContext added in v2.14.1 

func (i FlavorArray) ToFlavorArrayOutputWithContext(ctx context.Context) FlavorArrayOutput

type FlavorArrayInput added in v2.14.1 

type FlavorArrayInput interface {
	pulumi.Input

	ToFlavorArrayOutput() FlavorArrayOutput
	ToFlavorArrayOutputWithContext(context.Context) FlavorArrayOutput
}

FlavorArrayInput is an input type that accepts FlavorArray and FlavorArrayOutput values. You can construct a concrete instance of `FlavorArrayInput` via: 

FlavorArray{ FlavorArgs{...} }

type FlavorArrayOutput added in v2.14.1 

type FlavorArrayOutput struct{ *pulumi.OutputState }

func (FlavorArrayOutput) ElementType added in v2.14.1 

func (FlavorArrayOutput) ElementType() reflect.Type

func (FlavorArrayOutput) Index added in v2.14.1 

func (o FlavorArrayOutput) Index(i pulumi.IntInput) FlavorOutput

func (FlavorArrayOutput) ToFlavorArrayOutput added in v2.14.1 

func (o FlavorArrayOutput) ToFlavorArrayOutput() FlavorArrayOutput

func (FlavorArrayOutput) ToFlavorArrayOutputWithContext added in v2.14.1 

func (o FlavorArrayOutput) ToFlavorArrayOutputWithContext(ctx context.Context) FlavorArrayOutput

type FlavorInput added in v2.10.0 

type FlavorInput interface {
	pulumi.Input

	ToFlavorOutput() FlavorOutput
	ToFlavorOutputWithContext(ctx context.Context) FlavorOutput
}

type FlavorMap added in v2.14.1 

type FlavorMap map[string]FlavorInput

func (FlavorMap) ElementType added in v2.14.1 

func (FlavorMap) ElementType() reflect.Type

func (FlavorMap) ToFlavorMapOutput added in v2.14.1 

func (i FlavorMap) ToFlavorMapOutput() FlavorMapOutput

func (FlavorMap) ToFlavorMapOutputWithContext added in v2.14.1 

func (i FlavorMap) ToFlavorMapOutputWithContext(ctx context.Context) FlavorMapOutput

type FlavorMapInput added in v2.14.1 

type FlavorMapInput interface {
	pulumi.Input

	ToFlavorMapOutput() FlavorMapOutput
	ToFlavorMapOutputWithContext(context.Context) FlavorMapOutput
}

FlavorMapInput is an input type that accepts FlavorMap and FlavorMapOutput values. You can construct a concrete instance of `FlavorMapInput` via: 

FlavorMap{ "key": FlavorArgs{...} }

type FlavorMapOutput added in v2.14.1 

type FlavorMapOutput struct{ *pulumi.OutputState }

func (FlavorMapOutput) ElementType added in v2.14.1 

func (FlavorMapOutput) ElementType() reflect.Type

func (FlavorMapOutput) MapIndex added in v2.14.1 

func (o FlavorMapOutput) MapIndex(k pulumi.StringInput) FlavorOutput

func (FlavorMapOutput) ToFlavorMapOutput added in v2.14.1 

func (o FlavorMapOutput) ToFlavorMapOutput() FlavorMapOutput

func (FlavorMapOutput) ToFlavorMapOutputWithContext added in v2.14.1 

func (o FlavorMapOutput) ToFlavorMapOutputWithContext(ctx context.Context) FlavorMapOutput

type FlavorOutput added in v2.10.0 

type FlavorOutput struct {
	*pulumi.OutputState
}

func (FlavorOutput) ElementType added in v2.10.0 

func (FlavorOutput) ElementType() reflect.Type

func (FlavorOutput) ToFlavorOutput added in v2.10.0 

func (o FlavorOutput) ToFlavorOutput() FlavorOutput

func (FlavorOutput) ToFlavorOutputWithContext added in v2.10.0 

func (o FlavorOutput) ToFlavorOutputWithContext(ctx context.Context) FlavorOutput

func (FlavorOutput) ToFlavorPtrOutput added in v2.14.1 

func (o FlavorOutput) ToFlavorPtrOutput() FlavorPtrOutput

func (FlavorOutput) ToFlavorPtrOutputWithContext added in v2.14.1 

func (o FlavorOutput) ToFlavorPtrOutputWithContext(ctx context.Context) FlavorPtrOutput

type FlavorPtrInput added in v2.14.1 

type FlavorPtrInput interface {
	pulumi.Input

	ToFlavorPtrOutput() FlavorPtrOutput
	ToFlavorPtrOutputWithContext(ctx context.Context) FlavorPtrOutput
}

type FlavorPtrOutput added in v2.14.1 

type FlavorPtrOutput struct {
	*pulumi.OutputState
}

func (FlavorPtrOutput) ElementType added in v2.14.1 

func (FlavorPtrOutput) ElementType() reflect.Type

func (FlavorPtrOutput) ToFlavorPtrOutput added in v2.14.1 

func (o FlavorPtrOutput) ToFlavorPtrOutput() FlavorPtrOutput

func (FlavorPtrOutput) ToFlavorPtrOutputWithContext added in v2.14.1 

func (o FlavorPtrOutput) ToFlavorPtrOutputWithContext(ctx context.Context) FlavorPtrOutput

type FlavorState 

type FlavorState struct {
	// The amount of disk space in GiB to use for the root
	// (/) partition. Changing this creates a new flavor.
	Disk pulumi.IntPtrInput
	// The amount of ephemeral in GiB. If unspecified,
	// the default is 0. Changing this creates a new flavor.
	Ephemeral pulumi.IntPtrInput
	// Key/Value pairs of metadata for the flavor.
	ExtraSpecs pulumi.MapInput
	// Unique ID (integer or UUID) of flavor to create. Changing
	// this creates a new flavor.
	FlavorId pulumi.StringPtrInput
	// Whether the flavor is public. Changing this creates
	// a new flavor.
	IsPublic pulumi.BoolPtrInput
	// A unique name for the flavor. Changing this creates a new
	// flavor.
	Name pulumi.StringPtrInput
	// The amount of RAM to use, in megabytes. Changing this
	// creates a new flavor.
	Ram pulumi.IntPtrInput
	// The region in which to obtain the V2 Compute client.
	// Flavors are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new flavor.
	Region pulumi.StringPtrInput
	// RX/TX bandwith factor. The default is 1. Changing
	// this creates a new flavor.
	RxTxFactor pulumi.Float64PtrInput
	// The amount of disk space in megabytes to use. If
	// unspecified, the default is 0. Changing this creates a new flavor.
	Swap pulumi.IntPtrInput
	// The number of virtual CPUs to use. Changing this creates
	// a new flavor.
	Vcpus pulumi.IntPtrInput
}

func (FlavorState) ElementType 

func (FlavorState) ElementType() reflect.Type

type FloatingIp 

type FloatingIp struct {
	pulumi.CustomResourceState

	// The actual floating IP address itself.
	Address pulumi.StringOutput `pulumi:"address"`
	// The fixed IP address corresponding to the floating IP.
	FixedIp pulumi.StringOutput `pulumi:"fixedIp"`
	// UUID of the compute instance associated with the floating IP.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
	// The name of the pool from which to obtain the floating
	// IP. Changing this creates a new floating IP.
	Pool pulumi.StringOutput `pulumi:"pool"`
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a floating IP that can be used with
	// a compute instance. If omitted, the `region` argument of the provider
	// is used. Changing this creates a new floating IP (which may or may not
	// have a different address).
	Region pulumi.StringOutput `pulumi:"region"`
}

Manages a V2 floating IP resource within OpenStack Nova (compute) that can be used for compute instances.

Please note that managing floating IPs through the OpenStack Compute API has been deprecated. Unless you are using an older OpenStack environment, it is recommended to use the `networking.FloatingIp` resource instead, which uses the OpenStack Networking API.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewFloatingIp(ctx, "floatip1", &compute.FloatingIpArgs{
			Pool: pulumi.String("public"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Floating IPs can be imported using the `id`, e.g.

```sh 

$ pulumi import openstack:compute/floatingIp:FloatingIp floatip_1 89c60255-9bd6-460c-822a-e2b959ede9d2

```

func GetFloatingIp 

func GetFloatingIp(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FloatingIpState, opts ...pulumi.ResourceOption) (*FloatingIp, error)

GetFloatingIp gets an existing FloatingIp resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFloatingIp 

func NewFloatingIp(ctx *pulumi.Context,
	name string, args *FloatingIpArgs, opts ...pulumi.ResourceOption) (*FloatingIp, error)

NewFloatingIp registers a new resource with the given unique name, arguments, and options.

func (*FloatingIp) ElementType added in v2.10.0 

func (*FloatingIp) ElementType() reflect.Type

func (*FloatingIp) ToFloatingIpOutput added in v2.10.0 

func (i *FloatingIp) ToFloatingIpOutput() FloatingIpOutput

func (*FloatingIp) ToFloatingIpOutputWithContext added in v2.10.0 

func (i *FloatingIp) ToFloatingIpOutputWithContext(ctx context.Context) FloatingIpOutput

func (*FloatingIp) ToFloatingIpPtrOutput added in v2.14.1 

func (i *FloatingIp) ToFloatingIpPtrOutput() FloatingIpPtrOutput

func (*FloatingIp) ToFloatingIpPtrOutputWithContext added in v2.14.1 

func (i *FloatingIp) ToFloatingIpPtrOutputWithContext(ctx context.Context) FloatingIpPtrOutput

type FloatingIpArgs 

type FloatingIpArgs struct {
	// The name of the pool from which to obtain the floating
	// IP. Changing this creates a new floating IP.
	Pool pulumi.StringInput
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a floating IP that can be used with
	// a compute instance. If omitted, the `region` argument of the provider
	// is used. Changing this creates a new floating IP (which may or may not
	// have a different address).
	Region pulumi.StringPtrInput
}

The set of arguments for constructing a FloatingIp resource.

func (FloatingIpArgs) ElementType 

func (FloatingIpArgs) ElementType() reflect.Type

type FloatingIpArray added in v2.14.1 

type FloatingIpArray []FloatingIpInput

func (FloatingIpArray) ElementType added in v2.14.1 

func (FloatingIpArray) ElementType() reflect.Type

func (FloatingIpArray) ToFloatingIpArrayOutput added in v2.14.1 

func (i FloatingIpArray) ToFloatingIpArrayOutput() FloatingIpArrayOutput

func (FloatingIpArray) ToFloatingIpArrayOutputWithContext added in v2.14.1 

func (i FloatingIpArray) ToFloatingIpArrayOutputWithContext(ctx context.Context) FloatingIpArrayOutput

type FloatingIpArrayInput added in v2.14.1 

type FloatingIpArrayInput interface {
	pulumi.Input

	ToFloatingIpArrayOutput() FloatingIpArrayOutput
	ToFloatingIpArrayOutputWithContext(context.Context) FloatingIpArrayOutput
}

FloatingIpArrayInput is an input type that accepts FloatingIpArray and FloatingIpArrayOutput values. You can construct a concrete instance of `FloatingIpArrayInput` via: 

FloatingIpArray{ FloatingIpArgs{...} }

type FloatingIpArrayOutput added in v2.14.1 

type FloatingIpArrayOutput struct{ *pulumi.OutputState }

func (FloatingIpArrayOutput) ElementType added in v2.14.1 

func (FloatingIpArrayOutput) ElementType() reflect.Type

func (FloatingIpArrayOutput) Index added in v2.14.1 

func (o FloatingIpArrayOutput) Index(i pulumi.IntInput) FloatingIpOutput

func (FloatingIpArrayOutput) ToFloatingIpArrayOutput added in v2.14.1 

func (o FloatingIpArrayOutput) ToFloatingIpArrayOutput() FloatingIpArrayOutput

func (FloatingIpArrayOutput) ToFloatingIpArrayOutputWithContext added in v2.14.1 

func (o FloatingIpArrayOutput) ToFloatingIpArrayOutputWithContext(ctx context.Context) FloatingIpArrayOutput

type FloatingIpAssociate 

type FloatingIpAssociate struct {
	pulumi.CustomResourceState

	// The specific IP address to direct traffic to.
	FixedIp pulumi.StringPtrOutput `pulumi:"fixedIp"`
	// The floating IP to associate.
	FloatingIp pulumi.StringOutput `pulumi:"floatingIp"`
	// The instance to associte the floating IP with.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
	// The region in which to obtain the V2 Compute client.
	// Keypairs are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new floatingip_associate.
	Region              pulumi.StringOutput  `pulumi:"region"`
	WaitUntilAssociated pulumi.BoolPtrOutput `pulumi:"waitUntilAssociated"`
}

Associate a floating IP to an instance.

## Example Usage ### Automatically detect the correct network

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/networking"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			FlavorId: pulumi.String("3"),
			ImageId:  pulumi.String("ad091b52-742f-469e-8f3c-fd81cadf0743"),
			KeyPair:  pulumi.String("my_key_pair_name"),
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		fip1FloatingIp, err := networking.NewFloatingIp(ctx, "fip1FloatingIp", &networking.FloatingIpArgs{
			Pool: pulumi.String("my_pool"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewFloatingIpAssociate(ctx, "fip1FloatingIpAssociate", &compute.FloatingIpAssociateArgs{
			FloatingIp: fip1FloatingIp.Address,
			InstanceId: instance1.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Explicitly set the network to attach to

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/networking"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			FlavorId: pulumi.String("3"),
			ImageId:  pulumi.String("ad091b52-742f-469e-8f3c-fd81cadf0743"),
			KeyPair:  pulumi.String("my_key_pair_name"),
			Networks: compute.InstanceNetworkArray{
				&compute.InstanceNetworkArgs{
					Name: pulumi.String("my_network"),
				},
				&compute.InstanceNetworkArgs{
					Name: pulumi.String("default"),
				},
			},
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		fip1FloatingIp, err := networking.NewFloatingIp(ctx, "fip1FloatingIp", &networking.FloatingIpArgs{
			Pool: pulumi.String("my_pool"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewFloatingIpAssociate(ctx, "fip1FloatingIpAssociate", &compute.FloatingIpAssociateArgs{
			FixedIp: instance1.Networks.ApplyT(func(networks []compute.InstanceNetwork) (string, error) {
				return networks[1].FixedIpV4, nil
			}).(pulumi.StringOutput),
			FloatingIp: fip1FloatingIp.Address,
			InstanceId: instance1.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

This resource can be imported by specifying all three arguments, separated by a forward slash

```sh 

$ pulumi import openstack:compute/floatingIpAssociate:FloatingIpAssociate fip_1 <floating_ip>/<instance_id>/<fixed_ip>

```

func GetFloatingIpAssociate 

func GetFloatingIpAssociate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FloatingIpAssociateState, opts ...pulumi.ResourceOption) (*FloatingIpAssociate, error)

GetFloatingIpAssociate gets an existing FloatingIpAssociate resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFloatingIpAssociate 

func NewFloatingIpAssociate(ctx *pulumi.Context,
	name string, args *FloatingIpAssociateArgs, opts ...pulumi.ResourceOption) (*FloatingIpAssociate, error)

NewFloatingIpAssociate registers a new resource with the given unique name, arguments, and options.

func (*FloatingIpAssociate) ElementType added in v2.10.0 

func (*FloatingIpAssociate) ElementType() reflect.Type

func (*FloatingIpAssociate) ToFloatingIpAssociateOutput added in v2.10.0 

func (i *FloatingIpAssociate) ToFloatingIpAssociateOutput() FloatingIpAssociateOutput

func (*FloatingIpAssociate) ToFloatingIpAssociateOutputWithContext added in v2.10.0 

func (i *FloatingIpAssociate) ToFloatingIpAssociateOutputWithContext(ctx context.Context) FloatingIpAssociateOutput

func (*FloatingIpAssociate) ToFloatingIpAssociatePtrOutput added in v2.14.1 

func (i *FloatingIpAssociate) ToFloatingIpAssociatePtrOutput() FloatingIpAssociatePtrOutput

func (*FloatingIpAssociate) ToFloatingIpAssociatePtrOutputWithContext added in v2.14.1 

func (i *FloatingIpAssociate) ToFloatingIpAssociatePtrOutputWithContext(ctx context.Context) FloatingIpAssociatePtrOutput

type FloatingIpAssociateArgs 

type FloatingIpAssociateArgs struct {
	// The specific IP address to direct traffic to.
	FixedIp pulumi.StringPtrInput
	// The floating IP to associate.
	FloatingIp pulumi.StringInput
	// The instance to associte the floating IP with.
	InstanceId pulumi.StringInput
	// The region in which to obtain the V2 Compute client.
	// Keypairs are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new floatingip_associate.
	Region              pulumi.StringPtrInput
	WaitUntilAssociated pulumi.BoolPtrInput
}

The set of arguments for constructing a FloatingIpAssociate resource.

func (FloatingIpAssociateArgs) ElementType 

func (FloatingIpAssociateArgs) ElementType() reflect.Type

type FloatingIpAssociateArray added in v2.14.1 

type FloatingIpAssociateArray []FloatingIpAssociateInput

func (FloatingIpAssociateArray) ElementType added in v2.14.1 

func (FloatingIpAssociateArray) ElementType() reflect.Type

func (FloatingIpAssociateArray) ToFloatingIpAssociateArrayOutput added in v2.14.1 

func (i FloatingIpAssociateArray) ToFloatingIpAssociateArrayOutput() FloatingIpAssociateArrayOutput

func (FloatingIpAssociateArray) ToFloatingIpAssociateArrayOutputWithContext added in v2.14.1 

func (i FloatingIpAssociateArray) ToFloatingIpAssociateArrayOutputWithContext(ctx context.Context) FloatingIpAssociateArrayOutput

type FloatingIpAssociateArrayInput added in v2.14.1 

type FloatingIpAssociateArrayInput interface {
	pulumi.Input

	ToFloatingIpAssociateArrayOutput() FloatingIpAssociateArrayOutput
	ToFloatingIpAssociateArrayOutputWithContext(context.Context) FloatingIpAssociateArrayOutput
}

FloatingIpAssociateArrayInput is an input type that accepts FloatingIpAssociateArray and FloatingIpAssociateArrayOutput values. You can construct a concrete instance of `FloatingIpAssociateArrayInput` via: 

FloatingIpAssociateArray{ FloatingIpAssociateArgs{...} }

type FloatingIpAssociateArrayOutput added in v2.14.1 

type FloatingIpAssociateArrayOutput struct{ *pulumi.OutputState }

func (FloatingIpAssociateArrayOutput) ElementType added in v2.14.1 

func (FloatingIpAssociateArrayOutput) ElementType() reflect.Type

func (FloatingIpAssociateArrayOutput) Index added in v2.14.1 

func (o FloatingIpAssociateArrayOutput) Index(i pulumi.IntInput) FloatingIpAssociateOutput

func (FloatingIpAssociateArrayOutput) ToFloatingIpAssociateArrayOutput added in v2.14.1 

func (o FloatingIpAssociateArrayOutput) ToFloatingIpAssociateArrayOutput() FloatingIpAssociateArrayOutput

func (FloatingIpAssociateArrayOutput) ToFloatingIpAssociateArrayOutputWithContext added in v2.14.1 

func (o FloatingIpAssociateArrayOutput) ToFloatingIpAssociateArrayOutputWithContext(ctx context.Context) FloatingIpAssociateArrayOutput

type FloatingIpAssociateInput added in v2.10.0 

type FloatingIpAssociateInput interface {
	pulumi.Input

	ToFloatingIpAssociateOutput() FloatingIpAssociateOutput
	ToFloatingIpAssociateOutputWithContext(ctx context.Context) FloatingIpAssociateOutput
}

type FloatingIpAssociateMap added in v2.14.1 

type FloatingIpAssociateMap map[string]FloatingIpAssociateInput

func (FloatingIpAssociateMap) ElementType added in v2.14.1 

func (FloatingIpAssociateMap) ElementType() reflect.Type

func (FloatingIpAssociateMap) ToFloatingIpAssociateMapOutput added in v2.14.1 

func (i FloatingIpAssociateMap) ToFloatingIpAssociateMapOutput() FloatingIpAssociateMapOutput

func (FloatingIpAssociateMap) ToFloatingIpAssociateMapOutputWithContext added in v2.14.1 

func (i FloatingIpAssociateMap) ToFloatingIpAssociateMapOutputWithContext(ctx context.Context) FloatingIpAssociateMapOutput

type FloatingIpAssociateMapInput added in v2.14.1 

type FloatingIpAssociateMapInput interface {
	pulumi.Input

	ToFloatingIpAssociateMapOutput() FloatingIpAssociateMapOutput
	ToFloatingIpAssociateMapOutputWithContext(context.Context) FloatingIpAssociateMapOutput
}

FloatingIpAssociateMapInput is an input type that accepts FloatingIpAssociateMap and FloatingIpAssociateMapOutput values. You can construct a concrete instance of `FloatingIpAssociateMapInput` via: 

FloatingIpAssociateMap{ "key": FloatingIpAssociateArgs{...} }

type FloatingIpAssociateMapOutput added in v2.14.1 

type FloatingIpAssociateMapOutput struct{ *pulumi.OutputState }

func (FloatingIpAssociateMapOutput) ElementType added in v2.14.1 

func (FloatingIpAssociateMapOutput) ElementType() reflect.Type

func (FloatingIpAssociateMapOutput) MapIndex added in v2.14.1 

func (o FloatingIpAssociateMapOutput) MapIndex(k pulumi.StringInput) FloatingIpAssociateOutput

func (FloatingIpAssociateMapOutput) ToFloatingIpAssociateMapOutput added in v2.14.1 

func (o FloatingIpAssociateMapOutput) ToFloatingIpAssociateMapOutput() FloatingIpAssociateMapOutput

func (FloatingIpAssociateMapOutput) ToFloatingIpAssociateMapOutputWithContext added in v2.14.1 

func (o FloatingIpAssociateMapOutput) ToFloatingIpAssociateMapOutputWithContext(ctx context.Context) FloatingIpAssociateMapOutput

type FloatingIpAssociateOutput added in v2.10.0 

type FloatingIpAssociateOutput struct {
	*pulumi.OutputState
}

func (FloatingIpAssociateOutput) ElementType added in v2.10.0 

func (FloatingIpAssociateOutput) ElementType() reflect.Type

func (FloatingIpAssociateOutput) ToFloatingIpAssociateOutput added in v2.10.0 

func (o FloatingIpAssociateOutput) ToFloatingIpAssociateOutput() FloatingIpAssociateOutput

func (FloatingIpAssociateOutput) ToFloatingIpAssociateOutputWithContext added in v2.10.0 

func (o FloatingIpAssociateOutput) ToFloatingIpAssociateOutputWithContext(ctx context.Context) FloatingIpAssociateOutput

func (FloatingIpAssociateOutput) ToFloatingIpAssociatePtrOutput added in v2.14.1 

func (o FloatingIpAssociateOutput) ToFloatingIpAssociatePtrOutput() FloatingIpAssociatePtrOutput

func (FloatingIpAssociateOutput) ToFloatingIpAssociatePtrOutputWithContext added in v2.14.1 

func (o FloatingIpAssociateOutput) ToFloatingIpAssociatePtrOutputWithContext(ctx context.Context) FloatingIpAssociatePtrOutput

type FloatingIpAssociatePtrInput added in v2.14.1 

type FloatingIpAssociatePtrInput interface {
	pulumi.Input

	ToFloatingIpAssociatePtrOutput() FloatingIpAssociatePtrOutput
	ToFloatingIpAssociatePtrOutputWithContext(ctx context.Context) FloatingIpAssociatePtrOutput
}

type FloatingIpAssociatePtrOutput added in v2.14.1 

type FloatingIpAssociatePtrOutput struct {
	*pulumi.OutputState
}

func (FloatingIpAssociatePtrOutput) ElementType added in v2.14.1 

func (FloatingIpAssociatePtrOutput) ElementType() reflect.Type

func (FloatingIpAssociatePtrOutput) ToFloatingIpAssociatePtrOutput added in v2.14.1 

func (o FloatingIpAssociatePtrOutput) ToFloatingIpAssociatePtrOutput() FloatingIpAssociatePtrOutput

func (FloatingIpAssociatePtrOutput) ToFloatingIpAssociatePtrOutputWithContext added in v2.14.1 

func (o FloatingIpAssociatePtrOutput) ToFloatingIpAssociatePtrOutputWithContext(ctx context.Context) FloatingIpAssociatePtrOutput

type FloatingIpAssociateState 

type FloatingIpAssociateState struct {
	// The specific IP address to direct traffic to.
	FixedIp pulumi.StringPtrInput
	// The floating IP to associate.
	FloatingIp pulumi.StringPtrInput
	// The instance to associte the floating IP with.
	InstanceId pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// Keypairs are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new floatingip_associate.
	Region              pulumi.StringPtrInput
	WaitUntilAssociated pulumi.BoolPtrInput
}

func (FloatingIpAssociateState) ElementType 

func (FloatingIpAssociateState) ElementType() reflect.Type

type FloatingIpInput added in v2.10.0 

type FloatingIpInput interface {
	pulumi.Input

	ToFloatingIpOutput() FloatingIpOutput
	ToFloatingIpOutputWithContext(ctx context.Context) FloatingIpOutput
}

type FloatingIpMap added in v2.14.1 

type FloatingIpMap map[string]FloatingIpInput

func (FloatingIpMap) ElementType added in v2.14.1 

func (FloatingIpMap) ElementType() reflect.Type

func (FloatingIpMap) ToFloatingIpMapOutput added in v2.14.1 

func (i FloatingIpMap) ToFloatingIpMapOutput() FloatingIpMapOutput

func (FloatingIpMap) ToFloatingIpMapOutputWithContext added in v2.14.1 

func (i FloatingIpMap) ToFloatingIpMapOutputWithContext(ctx context.Context) FloatingIpMapOutput

type FloatingIpMapInput added in v2.14.1 

type FloatingIpMapInput interface {
	pulumi.Input

	ToFloatingIpMapOutput() FloatingIpMapOutput
	ToFloatingIpMapOutputWithContext(context.Context) FloatingIpMapOutput
}

FloatingIpMapInput is an input type that accepts FloatingIpMap and FloatingIpMapOutput values. You can construct a concrete instance of `FloatingIpMapInput` via: 

FloatingIpMap{ "key": FloatingIpArgs{...} }

type FloatingIpMapOutput added in v2.14.1 

type FloatingIpMapOutput struct{ *pulumi.OutputState }

func (FloatingIpMapOutput) ElementType added in v2.14.1 

func (FloatingIpMapOutput) ElementType() reflect.Type

func (FloatingIpMapOutput) MapIndex added in v2.14.1 

func (o FloatingIpMapOutput) MapIndex(k pulumi.StringInput) FloatingIpOutput

func (FloatingIpMapOutput) ToFloatingIpMapOutput added in v2.14.1 

func (o FloatingIpMapOutput) ToFloatingIpMapOutput() FloatingIpMapOutput

func (FloatingIpMapOutput) ToFloatingIpMapOutputWithContext added in v2.14.1 

func (o FloatingIpMapOutput) ToFloatingIpMapOutputWithContext(ctx context.Context) FloatingIpMapOutput

type FloatingIpOutput added in v2.10.0 

type FloatingIpOutput struct {
	*pulumi.OutputState
}

func (FloatingIpOutput) ElementType added in v2.10.0 

func (FloatingIpOutput) ElementType() reflect.Type

func (FloatingIpOutput) ToFloatingIpOutput added in v2.10.0 

func (o FloatingIpOutput) ToFloatingIpOutput() FloatingIpOutput

func (FloatingIpOutput) ToFloatingIpOutputWithContext added in v2.10.0 

func (o FloatingIpOutput) ToFloatingIpOutputWithContext(ctx context.Context) FloatingIpOutput

func (FloatingIpOutput) ToFloatingIpPtrOutput added in v2.14.1 

func (o FloatingIpOutput) ToFloatingIpPtrOutput() FloatingIpPtrOutput

func (FloatingIpOutput) ToFloatingIpPtrOutputWithContext added in v2.14.1 

func (o FloatingIpOutput) ToFloatingIpPtrOutputWithContext(ctx context.Context) FloatingIpPtrOutput

type FloatingIpPtrInput added in v2.14.1 

type FloatingIpPtrInput interface {
	pulumi.Input

	ToFloatingIpPtrOutput() FloatingIpPtrOutput
	ToFloatingIpPtrOutputWithContext(ctx context.Context) FloatingIpPtrOutput
}

type FloatingIpPtrOutput added in v2.14.1 

type FloatingIpPtrOutput struct {
	*pulumi.OutputState
}

func (FloatingIpPtrOutput) ElementType added in v2.14.1 

func (FloatingIpPtrOutput) ElementType() reflect.Type

func (FloatingIpPtrOutput) ToFloatingIpPtrOutput added in v2.14.1 

func (o FloatingIpPtrOutput) ToFloatingIpPtrOutput() FloatingIpPtrOutput

func (FloatingIpPtrOutput) ToFloatingIpPtrOutputWithContext added in v2.14.1 

func (o FloatingIpPtrOutput) ToFloatingIpPtrOutputWithContext(ctx context.Context) FloatingIpPtrOutput

type FloatingIpState 

type FloatingIpState struct {
	// The actual floating IP address itself.
	Address pulumi.StringPtrInput
	// The fixed IP address corresponding to the floating IP.
	FixedIp pulumi.StringPtrInput
	// UUID of the compute instance associated with the floating IP.
	InstanceId pulumi.StringPtrInput
	// The name of the pool from which to obtain the floating
	// IP. Changing this creates a new floating IP.
	Pool pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a floating IP that can be used with
	// a compute instance. If omitted, the `region` argument of the provider
	// is used. Changing this creates a new floating IP (which may or may not
	// have a different address).
	Region pulumi.StringPtrInput
}

func (FloatingIpState) ElementType 

func (FloatingIpState) ElementType() reflect.Type

type GetAvailabilityZonesArgs 

type GetAvailabilityZonesArgs struct {
	// The `region` to fetch availability zones from, defaults to the provider's `region`
	Region *string `pulumi:"region"`
	// The `state` of the availability zones to match, default ("available").
	State *string `pulumi:"state"`
}

A collection of arguments for invoking getAvailabilityZones.

type GetAvailabilityZonesResult 

type GetAvailabilityZonesResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The names of the availability zones, ordered alphanumerically, that match the queried `state`
	Names  []string `pulumi:"names"`
	Region string   `pulumi:"region"`
	State  *string  `pulumi:"state"`
}

A collection of values returned by getAvailabilityZones.

func GetAvailabilityZones 

func GetAvailabilityZones(ctx *pulumi.Context, args *GetAvailabilityZonesArgs, opts ...pulumi.InvokeOption) (*GetAvailabilityZonesResult, error)

Use this data source to get a list of availability zones from OpenStack

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.GetAvailabilityZones(ctx, nil, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetHypervisorV2Args added in v2.11.0 

type GetHypervisorV2Args struct {
	// The hostname of the hypervisor
	Hostname string `pulumi:"hostname"`
}

A collection of arguments for invoking getHypervisorV2.

type GetHypervisorV2Result added in v2.11.0 

type GetHypervisorV2Result struct {
	// The amount in GigaBytes of local storage the hypervisor can provide
	Disk int `pulumi:"disk"`
	// The IP address of the Hypervisor
	HostIp string `pulumi:"hostIp"`
	// See Argument Reference above.
	Hostname string `pulumi:"hostname"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The number in MegaBytes of memory the hypervisor can provide
	Memory int `pulumi:"memory"`
	// The state of the hypervisor (`up` or `down`)
	State string `pulumi:"state"`
	// The status of the hypervisor (`enabled` or `disabled`)
	Status string `pulumi:"status"`
	// The type of the hypervisor (example: `QEMU`)
	Type string `pulumi:"type"`
	// The number of virtual CPUs the hypervisor can provide
	Vcpus int `pulumi:"vcpus"`
}

A collection of values returned by getHypervisorV2.

func GetHypervisorV2 added in v2.11.0 

func GetHypervisorV2(ctx *pulumi.Context, args *GetHypervisorV2Args, opts ...pulumi.InvokeOption) (*GetHypervisorV2Result, error)

Use this data source to get information about hypervisors by hostname.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.GetHypervisorV2(ctx, &compute.GetHypervisorV2Args{
			Hostname: "host01",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetInstanceV2Args added in v2.6.0 

type GetInstanceV2Args struct {
	// The UUID of the instance
	Id string `pulumi:"id"`
	// An array of maps, detailed below.
	Networks []GetInstanceV2Network `pulumi:"networks"`
	Region   *string                `pulumi:"region"`
	// The user data added when the server was created.
	UserData *string `pulumi:"userData"`
}

A collection of arguments for invoking getInstanceV2.

type GetInstanceV2Network added in v2.6.0 

type GetInstanceV2Network struct {
	// The IPv4 address assigned to this network port.
	FixedIpV4 string `pulumi:"fixedIpV4"`
	// The IPv6 address assigned to this network port.
	FixedIpV6 string `pulumi:"fixedIpV6"`
	// The MAC address assigned to this network interface.
	Mac string `pulumi:"mac"`
	// The name of the network
	Name string `pulumi:"name"`
	// The port UUID for this network
	Port string `pulumi:"port"`
	// The UUID of the network
	Uuid string `pulumi:"uuid"`
}

type GetInstanceV2NetworkArgs added in v2.6.0 

type GetInstanceV2NetworkArgs struct {
	// The IPv4 address assigned to this network port.
	FixedIpV4 pulumi.StringInput `pulumi:"fixedIpV4"`
	// The IPv6 address assigned to this network port.
	FixedIpV6 pulumi.StringInput `pulumi:"fixedIpV6"`
	// The MAC address assigned to this network interface.
	Mac pulumi.StringInput `pulumi:"mac"`
	// The name of the network
	Name pulumi.StringInput `pulumi:"name"`
	// The port UUID for this network
	Port pulumi.StringInput `pulumi:"port"`
	// The UUID of the network
	Uuid pulumi.StringInput `pulumi:"uuid"`
}

func (GetInstanceV2NetworkArgs) ElementType added in v2.6.0 

func (GetInstanceV2NetworkArgs) ElementType() reflect.Type

func (GetInstanceV2NetworkArgs) ToGetInstanceV2NetworkOutput added in v2.6.0 

func (i GetInstanceV2NetworkArgs) ToGetInstanceV2NetworkOutput() GetInstanceV2NetworkOutput

func (GetInstanceV2NetworkArgs) ToGetInstanceV2NetworkOutputWithContext added in v2.6.0 

func (i GetInstanceV2NetworkArgs) ToGetInstanceV2NetworkOutputWithContext(ctx context.Context) GetInstanceV2NetworkOutput

type GetInstanceV2NetworkArray added in v2.6.0 

type GetInstanceV2NetworkArray []GetInstanceV2NetworkInput

func (GetInstanceV2NetworkArray) ElementType added in v2.6.0 

func (GetInstanceV2NetworkArray) ElementType() reflect.Type

func (GetInstanceV2NetworkArray) ToGetInstanceV2NetworkArrayOutput added in v2.6.0 

func (i GetInstanceV2NetworkArray) ToGetInstanceV2NetworkArrayOutput() GetInstanceV2NetworkArrayOutput

func (GetInstanceV2NetworkArray) ToGetInstanceV2NetworkArrayOutputWithContext added in v2.6.0 

func (i GetInstanceV2NetworkArray) ToGetInstanceV2NetworkArrayOutputWithContext(ctx context.Context) GetInstanceV2NetworkArrayOutput

type GetInstanceV2NetworkArrayInput added in v2.6.0 

type GetInstanceV2NetworkArrayInput interface {
	pulumi.Input

	ToGetInstanceV2NetworkArrayOutput() GetInstanceV2NetworkArrayOutput
	ToGetInstanceV2NetworkArrayOutputWithContext(context.Context) GetInstanceV2NetworkArrayOutput
}

GetInstanceV2NetworkArrayInput is an input type that accepts GetInstanceV2NetworkArray and GetInstanceV2NetworkArrayOutput values. You can construct a concrete instance of `GetInstanceV2NetworkArrayInput` via: 

GetInstanceV2NetworkArray{ GetInstanceV2NetworkArgs{...} }

type GetInstanceV2NetworkArrayOutput added in v2.6.0 

type GetInstanceV2NetworkArrayOutput struct{ *pulumi.OutputState }

func (GetInstanceV2NetworkArrayOutput) ElementType added in v2.6.0 

func (GetInstanceV2NetworkArrayOutput) ElementType() reflect.Type

func (GetInstanceV2NetworkArrayOutput) Index added in v2.6.0 

func (o GetInstanceV2NetworkArrayOutput) Index(i pulumi.IntInput) GetInstanceV2NetworkOutput

func (GetInstanceV2NetworkArrayOutput) ToGetInstanceV2NetworkArrayOutput added in v2.6.0 

func (o GetInstanceV2NetworkArrayOutput) ToGetInstanceV2NetworkArrayOutput() GetInstanceV2NetworkArrayOutput

func (GetInstanceV2NetworkArrayOutput) ToGetInstanceV2NetworkArrayOutputWithContext added in v2.6.0 

func (o GetInstanceV2NetworkArrayOutput) ToGetInstanceV2NetworkArrayOutputWithContext(ctx context.Context) GetInstanceV2NetworkArrayOutput

type GetInstanceV2NetworkInput added in v2.6.0 

type GetInstanceV2NetworkInput interface {
	pulumi.Input

	ToGetInstanceV2NetworkOutput() GetInstanceV2NetworkOutput
	ToGetInstanceV2NetworkOutputWithContext(context.Context) GetInstanceV2NetworkOutput
}

GetInstanceV2NetworkInput is an input type that accepts GetInstanceV2NetworkArgs and GetInstanceV2NetworkOutput values. You can construct a concrete instance of `GetInstanceV2NetworkInput` via: 

GetInstanceV2NetworkArgs{...}

type GetInstanceV2NetworkOutput added in v2.6.0 

type GetInstanceV2NetworkOutput struct{ *pulumi.OutputState }

func (GetInstanceV2NetworkOutput) ElementType added in v2.6.0 

func (GetInstanceV2NetworkOutput) ElementType() reflect.Type

func (GetInstanceV2NetworkOutput) FixedIpV4 added in v2.6.0 

func (o GetInstanceV2NetworkOutput) FixedIpV4() pulumi.StringOutput

The IPv4 address assigned to this network port.

func (GetInstanceV2NetworkOutput) FixedIpV6 added in v2.6.0 

func (o GetInstanceV2NetworkOutput) FixedIpV6() pulumi.StringOutput

The IPv6 address assigned to this network port.

func (GetInstanceV2NetworkOutput) Mac added in v2.6.0 

func (o GetInstanceV2NetworkOutput) Mac() pulumi.StringOutput

The MAC address assigned to this network interface.

func (GetInstanceV2NetworkOutput) Name added in v2.6.0 

func (o GetInstanceV2NetworkOutput) Name() pulumi.StringOutput

The name of the network

func (GetInstanceV2NetworkOutput) Port added in v2.6.0 

func (o GetInstanceV2NetworkOutput) Port() pulumi.StringOutput

The port UUID for this network

func (GetInstanceV2NetworkOutput) ToGetInstanceV2NetworkOutput added in v2.6.0 

func (o GetInstanceV2NetworkOutput) ToGetInstanceV2NetworkOutput() GetInstanceV2NetworkOutput

func (GetInstanceV2NetworkOutput) ToGetInstanceV2NetworkOutputWithContext added in v2.6.0 

func (o GetInstanceV2NetworkOutput) ToGetInstanceV2NetworkOutputWithContext(ctx context.Context) GetInstanceV2NetworkOutput

func (GetInstanceV2NetworkOutput) Uuid added in v2.6.0 

func (o GetInstanceV2NetworkOutput) Uuid() pulumi.StringOutput

The UUID of the network

type GetInstanceV2Result added in v2.6.0 

type GetInstanceV2Result struct {
	// The first IPv4 address assigned to this server.
	AccessIpV4 string `pulumi:"accessIpV4"`
	// The first IPv6 address assigned to this server.
	AccessIpV6 string `pulumi:"accessIpV6"`
	// The availability zone of this server.
	AvailabilityZone string `pulumi:"availabilityZone"`
	// The flavor ID used to create the server.
	FlavorId string `pulumi:"flavorId"`
	// The flavor name used to create the server.
	FlavorName string `pulumi:"flavorName"`
	Id         string `pulumi:"id"`
	// The image ID used to create the server.
	ImageId string `pulumi:"imageId"`
	// The name of the key pair assigned to this server.
	KeyPair string `pulumi:"keyPair"`
	// A set of key/value pairs made available to the server.
	Metadata map[string]interface{} `pulumi:"metadata"`
	// The name of the network
	Name string `pulumi:"name"`
	// An array of maps, detailed below.
	Networks []GetInstanceV2Network `pulumi:"networks"`
	Region   string                 `pulumi:"region"`
	// An array of security group names associated with this server.
	SecurityGroups []string `pulumi:"securityGroups"`
	// A set of string tags assigned to this server.
	Tags []string `pulumi:"tags"`
	// The user data added when the server was created.
	UserData string `pulumi:"userData"`
}

A collection of values returned by getInstanceV2.

func GetInstanceV2 added in v2.6.0 

func GetInstanceV2(ctx *pulumi.Context, args *GetInstanceV2Args, opts ...pulumi.InvokeOption) (*GetInstanceV2Result, error)

Use this data source to get the details of a running server

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.GetInstanceV2(ctx, &compute.GetInstanceV2Args{
			Id: "2ba26dc6-a12d-4889-8f25-794ea5bf4453",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type Instance 

type Instance struct {
	pulumi.CustomResourceState

	// The first detected Fixed IPv4 address.
	AccessIpV4 pulumi.StringOutput `pulumi:"accessIpV4"`
	// The first detected Fixed IPv6 address.
	AccessIpV6 pulumi.StringOutput `pulumi:"accessIpV6"`
	// The administrative password to assign to the server.
	// Changing this changes the root password on the existing server.
	AdminPass   pulumi.StringPtrOutput `pulumi:"adminPass"`
	AllMetadata pulumi.MapOutput       `pulumi:"allMetadata"`
	// The collection of tags assigned on the instance, which have
	// been explicitly and implicitly added.
	AllTags pulumi.StringArrayOutput `pulumi:"allTags"`
	// The availability zone in which to create
	// the server. Conflicts with `availabilityZoneHints`. Changing this creates
	// a new server.
	AvailabilityZone pulumi.StringOutput `pulumi:"availabilityZone"`
	// The availability zone in which to
	// create the server. This argument is preferred to `availabilityZone`, when
	// scheduling the server on a
	// [particular](https://docs.openstack.org/nova/latest/admin/availability-zones.html)
	// host or node. Conflicts with `availabilityZone`. Changing this creates a
	// new server.
	AvailabilityZoneHints pulumi.StringPtrOutput `pulumi:"availabilityZoneHints"`
	// Configuration of block devices. The blockDevice
	// structure is documented below. Changing this creates a new server.
	// You can specify multiple block devices which will create an instance with
	// multiple disks. This configuration is very flexible, so please see the
	// following [reference](https://docs.openstack.org/nova/latest/user/block-device-mapping.html)
	// for more information.
	BlockDevices InstanceBlockDeviceArrayOutput `pulumi:"blockDevices"`
	// Whether to use the configDrive feature to
	// configure the instance. Changing this creates a new server.
	ConfigDrive pulumi.BoolPtrOutput `pulumi:"configDrive"`
	// The flavor ID of
	// the desired flavor for the server. Changing this resizes the existing server.
	FlavorId pulumi.StringOutput `pulumi:"flavorId"`
	// The name of the
	// desired flavor for the server. Changing this resizes the existing server.
	FlavorName pulumi.StringOutput `pulumi:"flavorName"`
	// Whether to force the OpenStack instance to be
	// forcefully deleted. This is useful for environments that have reclaim / soft
	// deletion enabled.
	ForceDelete pulumi.BoolPtrOutput `pulumi:"forceDelete"`
	// (Optional; Required if `imageName` is empty and not booting
	// from a volume. Do not specify if booting from a volume.) The image ID of
	// the desired image for the server. Changing this creates a new server.
	ImageId pulumi.StringOutput `pulumi:"imageId"`
	// (Optional; Required if `imageId` is empty and not booting
	// from a volume. Do not specify if booting from a volume.) The name of the
	// desired image for the server. Changing this creates a new server.
	ImageName pulumi.StringOutput `pulumi:"imageName"`
	// The name of a key pair to put on the server. The key
	// pair must already be created and associated with the tenant's account.
	// Changing this creates a new server.
	KeyPair pulumi.StringPtrOutput `pulumi:"keyPair"`
	// Metadata key/value pairs to make available from
	// within the instance. Changing this updates the existing server metadata.
	Metadata pulumi.MapOutput `pulumi:"metadata"`
	// The human-readable
	// name of the network. Changing this creates a new server.
	Name pulumi.StringOutput `pulumi:"name"`
	// Special string for `network` option to create
	// the server. `networkMode` can be `"auto"` or `"none"`.
	// Please see the following [reference](https://docs.openstack.org/api-ref/compute/?expanded=create-server-detail#id11) for more information. Conflicts with `network`.
	NetworkMode pulumi.StringPtrOutput `pulumi:"networkMode"`
	// An array of one or more networks to attach to the
	// instance. The network object structure is documented below. Changing this
	// creates a new server.
	Networks InstanceNetworkArrayOutput `pulumi:"networks"`
	// Customize the personality of an instance by
	// defining one or more files and their contents. The personality structure
	// is described below.
	Personalities InstancePersonalityArrayOutput `pulumi:"personalities"`
	// Provide the VM state. Only 'active' and 'shutoff'
	// are supported values. *Note*: If the initial powerState is the shutoff
	// the VM will be stopped immediately after build and the provisioners like
	// remote-exec or files are not supported.
	PowerState pulumi.StringPtrOutput `pulumi:"powerState"`
	// The region in which to create the server instance. If
	// omitted, the `region` argument of the provider is used. Changing this
	// creates a new server.
	Region pulumi.StringOutput `pulumi:"region"`
	// Provide the Nova scheduler with hints on how
	// the instance should be launched. The available hints are described below.
	SchedulerHints InstanceSchedulerHintArrayOutput `pulumi:"schedulerHints"`
	// An array of one or more security group names
	// to associate with the server. Changing this results in adding/removing
	// security groups from the existing server. *Note*: When attaching the
	// instance to networks using Ports, place the security groups on the Port
	// and not the instance. *Note*: Names should be used and not ids, as ids
	// trigger unnecessary updates.
	SecurityGroups pulumi.StringArrayOutput `pulumi:"securityGroups"`
	// Whether to try stop instance gracefully
	// before destroying it, thus giving chance for guest OS daemons to stop correctly.
	// If instance doesn't stop within timeout, it will be destroyed anyway.
	StopBeforeDestroy pulumi.BoolPtrOutput `pulumi:"stopBeforeDestroy"`
	// A set of string tags for the instance. Changing this
	// updates the existing instance tags.
	Tags pulumi.StringArrayOutput `pulumi:"tags"`
	// The user data to provide when launching the instance.
	// Changing this creates a new server.
	UserData pulumi.StringPtrOutput `pulumi:"userData"`
	// Map of additional vendor-specific options.
	// Supported options are described below.
	VendorOptions InstanceVendorOptionsPtrOutput `pulumi:"vendorOptions"`
}

func GetInstance 

func GetInstance(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstanceState, opts ...pulumi.ResourceOption) (*Instance, error)

GetInstance gets an existing Instance resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInstance 

func NewInstance(ctx *pulumi.Context,
	name string, args *InstanceArgs, opts ...pulumi.ResourceOption) (*Instance, error)

NewInstance registers a new resource with the given unique name, arguments, and options.

func (*Instance) ElementType added in v2.10.0 

func (*Instance) ElementType() reflect.Type

func (*Instance) ToInstanceOutput added in v2.10.0 

func (i *Instance) ToInstanceOutput() InstanceOutput

func (*Instance) ToInstanceOutputWithContext added in v2.10.0 

func (i *Instance) ToInstanceOutputWithContext(ctx context.Context) InstanceOutput

func (*Instance) ToInstancePtrOutput added in v2.14.1 

func (i *Instance) ToInstancePtrOutput() InstancePtrOutput

func (*Instance) ToInstancePtrOutputWithContext added in v2.14.1 

func (i *Instance) ToInstancePtrOutputWithContext(ctx context.Context) InstancePtrOutput

type InstanceArgs 

type InstanceArgs struct {
	// The first detected Fixed IPv4 address.
	AccessIpV4 pulumi.StringPtrInput
	// The first detected Fixed IPv6 address.
	AccessIpV6 pulumi.StringPtrInput
	// The administrative password to assign to the server.
	// Changing this changes the root password on the existing server.
	AdminPass pulumi.StringPtrInput
	// The availability zone in which to create
	// the server. Conflicts with `availabilityZoneHints`. Changing this creates
	// a new server.
	AvailabilityZone pulumi.StringPtrInput
	// The availability zone in which to
	// create the server. This argument is preferred to `availabilityZone`, when
	// scheduling the server on a
	// [particular](https://docs.openstack.org/nova/latest/admin/availability-zones.html)
	// host or node. Conflicts with `availabilityZone`. Changing this creates a
	// new server.
	AvailabilityZoneHints pulumi.StringPtrInput
	// Configuration of block devices. The blockDevice
	// structure is documented below. Changing this creates a new server.
	// You can specify multiple block devices which will create an instance with
	// multiple disks. This configuration is very flexible, so please see the
	// following [reference](https://docs.openstack.org/nova/latest/user/block-device-mapping.html)
	// for more information.
	BlockDevices InstanceBlockDeviceArrayInput
	// Whether to use the configDrive feature to
	// configure the instance. Changing this creates a new server.
	ConfigDrive pulumi.BoolPtrInput
	// The flavor ID of
	// the desired flavor for the server. Changing this resizes the existing server.
	FlavorId pulumi.StringPtrInput
	// The name of the
	// desired flavor for the server. Changing this resizes the existing server.
	FlavorName pulumi.StringPtrInput
	// Whether to force the OpenStack instance to be
	// forcefully deleted. This is useful for environments that have reclaim / soft
	// deletion enabled.
	ForceDelete pulumi.BoolPtrInput
	// (Optional; Required if `imageName` is empty and not booting
	// from a volume. Do not specify if booting from a volume.) The image ID of
	// the desired image for the server. Changing this creates a new server.
	ImageId pulumi.StringPtrInput
	// (Optional; Required if `imageId` is empty and not booting
	// from a volume. Do not specify if booting from a volume.) The name of the
	// desired image for the server. Changing this creates a new server.
	ImageName pulumi.StringPtrInput
	// The name of a key pair to put on the server. The key
	// pair must already be created and associated with the tenant's account.
	// Changing this creates a new server.
	KeyPair pulumi.StringPtrInput
	// Metadata key/value pairs to make available from
	// within the instance. Changing this updates the existing server metadata.
	Metadata pulumi.MapInput
	// The human-readable
	// name of the network. Changing this creates a new server.
	Name pulumi.StringPtrInput
	// Special string for `network` option to create
	// the server. `networkMode` can be `"auto"` or `"none"`.
	// Please see the following [reference](https://docs.openstack.org/api-ref/compute/?expanded=create-server-detail#id11) for more information. Conflicts with `network`.
	NetworkMode pulumi.StringPtrInput
	// An array of one or more networks to attach to the
	// instance. The network object structure is documented below. Changing this
	// creates a new server.
	Networks InstanceNetworkArrayInput
	// Customize the personality of an instance by
	// defining one or more files and their contents. The personality structure
	// is described below.
	Personalities InstancePersonalityArrayInput
	// Provide the VM state. Only 'active' and 'shutoff'
	// are supported values. *Note*: If the initial powerState is the shutoff
	// the VM will be stopped immediately after build and the provisioners like
	// remote-exec or files are not supported.
	PowerState pulumi.StringPtrInput
	// The region in which to create the server instance. If
	// omitted, the `region` argument of the provider is used. Changing this
	// creates a new server.
	Region pulumi.StringPtrInput
	// Provide the Nova scheduler with hints on how
	// the instance should be launched. The available hints are described below.
	SchedulerHints InstanceSchedulerHintArrayInput
	// An array of one or more security group names
	// to associate with the server. Changing this results in adding/removing
	// security groups from the existing server. *Note*: When attaching the
	// instance to networks using Ports, place the security groups on the Port
	// and not the instance. *Note*: Names should be used and not ids, as ids
	// trigger unnecessary updates.
	SecurityGroups pulumi.StringArrayInput
	// Whether to try stop instance gracefully
	// before destroying it, thus giving chance for guest OS daemons to stop correctly.
	// If instance doesn't stop within timeout, it will be destroyed anyway.
	StopBeforeDestroy pulumi.BoolPtrInput
	// A set of string tags for the instance. Changing this
	// updates the existing instance tags.
	Tags pulumi.StringArrayInput
	// The user data to provide when launching the instance.
	// Changing this creates a new server.
	UserData pulumi.StringPtrInput
	// Map of additional vendor-specific options.
	// Supported options are described below.
	VendorOptions InstanceVendorOptionsPtrInput
}

The set of arguments for constructing a Instance resource.

func (InstanceArgs) ElementType 

func (InstanceArgs) ElementType() reflect.Type

type InstanceArray added in v2.14.1 

type InstanceArray []InstanceInput

func (InstanceArray) ElementType added in v2.14.1 

func (InstanceArray) ElementType() reflect.Type

func (InstanceArray) ToInstanceArrayOutput added in v2.14.1 

func (i InstanceArray) ToInstanceArrayOutput() InstanceArrayOutput

func (InstanceArray) ToInstanceArrayOutputWithContext added in v2.14.1 

func (i InstanceArray) ToInstanceArrayOutputWithContext(ctx context.Context) InstanceArrayOutput

type InstanceArrayInput added in v2.14.1 

type InstanceArrayInput interface {
	pulumi.Input

	ToInstanceArrayOutput() InstanceArrayOutput
	ToInstanceArrayOutputWithContext(context.Context) InstanceArrayOutput
}

InstanceArrayInput is an input type that accepts InstanceArray and InstanceArrayOutput values. You can construct a concrete instance of `InstanceArrayInput` via: 

InstanceArray{ InstanceArgs{...} }

type InstanceArrayOutput added in v2.14.1 

type InstanceArrayOutput struct{ *pulumi.OutputState }

func (InstanceArrayOutput) ElementType added in v2.14.1 

func (InstanceArrayOutput) ElementType() reflect.Type

func (InstanceArrayOutput) Index added in v2.14.1 

func (o InstanceArrayOutput) Index(i pulumi.IntInput) InstanceOutput

func (InstanceArrayOutput) ToInstanceArrayOutput added in v2.14.1 

func (o InstanceArrayOutput) ToInstanceArrayOutput() InstanceArrayOutput

func (InstanceArrayOutput) ToInstanceArrayOutputWithContext added in v2.14.1 

func (o InstanceArrayOutput) ToInstanceArrayOutputWithContext(ctx context.Context) InstanceArrayOutput

type InstanceBlockDevice 

type InstanceBlockDevice struct {
	// The boot index of the volume. It defaults to 0.
	// Changing this creates a new server.
	BootIndex *int `pulumi:"bootIndex"`
	// Delete the volume / block device upon
	// termination of the instance. Defaults to false. Changing this creates a
	// new server.
	DeleteOnTermination *bool `pulumi:"deleteOnTermination"`
	// The type that gets created. Possible values
	// are "volume" and "local". Changing this creates a new server.
	DestinationType *string `pulumi:"destinationType"`
	// The low-level device type that will be used. Most
	// common thing is to leave this empty. Changing this creates a new server.
	DeviceType *string `pulumi:"deviceType"`
	// The low-level disk bus that will be used. Most common
	// thing is to leave this empty. Changing this creates a new server.
	DiskBus *string `pulumi:"diskBus"`
	// Specifies the guest server disk file system format,
	// such as `ext2`, `ext3`, `ext4`, `xfs` or `swap`. Swap block device mappings
	// have the following restrictions: sourceType must be blank and destinationType
	// must be local and only one swap disk per server and the size of the swap disk
	// must be less than or equal to the swap size of the flavor. Changing this
	// creates a new server.
	GuestFormat *string `pulumi:"guestFormat"`
	// The source type of the device. Must be one of
	// "blank", "image", "volume", or "snapshot". Changing this creates a new
	// server.
	SourceType string `pulumi:"sourceType"`
	// The UUID of
	// the image, volume, or snapshot. Changing this creates a new server.
	Uuid *string `pulumi:"uuid"`
	// The size of the volume to create (in gigabytes). Required
	// in the following combinations: source=image and destination=volume,
	// source=blank and destination=local, and source=blank and destination=volume.
	// Changing this creates a new server.
	VolumeSize *int `pulumi:"volumeSize"`
	// The volume type that will be used, for example SSD
	// or HDD storage. The available options depend on how your specific OpenStack
	// cloud is configured and what classes of storage are provided. Changing this
	// creates a new server.
	VolumeType *string `pulumi:"volumeType"`
}

type InstanceBlockDeviceArgs 

type InstanceBlockDeviceArgs struct {
	// The boot index of the volume. It defaults to 0.
	// Changing this creates a new server.
	BootIndex pulumi.IntPtrInput `pulumi:"bootIndex"`
	// Delete the volume / block device upon
	// termination of the instance. Defaults to false. Changing this creates a
	// new server.
	DeleteOnTermination pulumi.BoolPtrInput `pulumi:"deleteOnTermination"`
	// The type that gets created. Possible values
	// are "volume" and "local". Changing this creates a new server.
	DestinationType pulumi.StringPtrInput `pulumi:"destinationType"`
	// The low-level device type that will be used. Most
	// common thing is to leave this empty. Changing this creates a new server.
	DeviceType pulumi.StringPtrInput `pulumi:"deviceType"`
	// The low-level disk bus that will be used. Most common
	// thing is to leave this empty. Changing this creates a new server.
	DiskBus pulumi.StringPtrInput `pulumi:"diskBus"`
	// Specifies the guest server disk file system format,
	// such as `ext2`, `ext3`, `ext4`, `xfs` or `swap`. Swap block device mappings
	// have the following restrictions: sourceType must be blank and destinationType
	// must be local and only one swap disk per server and the size of the swap disk
	// must be less than or equal to the swap size of the flavor. Changing this
	// creates a new server.
	GuestFormat pulumi.StringPtrInput `pulumi:"guestFormat"`
	// The source type of the device. Must be one of
	// "blank", "image", "volume", or "snapshot". Changing this creates a new
	// server.
	SourceType pulumi.StringInput `pulumi:"sourceType"`
	// The UUID of
	// the image, volume, or snapshot. Changing this creates a new server.
	Uuid pulumi.StringPtrInput `pulumi:"uuid"`
	// The size of the volume to create (in gigabytes). Required
	// in the following combinations: source=image and destination=volume,
	// source=blank and destination=local, and source=blank and destination=volume.
	// Changing this creates a new server.
	VolumeSize pulumi.IntPtrInput `pulumi:"volumeSize"`
	// The volume type that will be used, for example SSD
	// or HDD storage. The available options depend on how your specific OpenStack
	// cloud is configured and what classes of storage are provided. Changing this
	// creates a new server.
	VolumeType pulumi.StringPtrInput `pulumi:"volumeType"`
}

func (InstanceBlockDeviceArgs) ElementType 

func (InstanceBlockDeviceArgs) ElementType() reflect.Type

func (InstanceBlockDeviceArgs) ToInstanceBlockDeviceOutput 

func (i InstanceBlockDeviceArgs) ToInstanceBlockDeviceOutput() InstanceBlockDeviceOutput

func (InstanceBlockDeviceArgs) ToInstanceBlockDeviceOutputWithContext 

func (i InstanceBlockDeviceArgs) ToInstanceBlockDeviceOutputWithContext(ctx context.Context) InstanceBlockDeviceOutput

type InstanceBlockDeviceArray 

type InstanceBlockDeviceArray []InstanceBlockDeviceInput

func (InstanceBlockDeviceArray) ElementType 

func (InstanceBlockDeviceArray) ElementType() reflect.Type

func (InstanceBlockDeviceArray) ToInstanceBlockDeviceArrayOutput 

func (i InstanceBlockDeviceArray) ToInstanceBlockDeviceArrayOutput() InstanceBlockDeviceArrayOutput

func (InstanceBlockDeviceArray) ToInstanceBlockDeviceArrayOutputWithContext 

func (i InstanceBlockDeviceArray) ToInstanceBlockDeviceArrayOutputWithContext(ctx context.Context) InstanceBlockDeviceArrayOutput

type InstanceBlockDeviceArrayInput 

type InstanceBlockDeviceArrayInput interface {
	pulumi.Input

	ToInstanceBlockDeviceArrayOutput() InstanceBlockDeviceArrayOutput
	ToInstanceBlockDeviceArrayOutputWithContext(context.Context) InstanceBlockDeviceArrayOutput
}

InstanceBlockDeviceArrayInput is an input type that accepts InstanceBlockDeviceArray and InstanceBlockDeviceArrayOutput values. You can construct a concrete instance of `InstanceBlockDeviceArrayInput` via: 

InstanceBlockDeviceArray{ InstanceBlockDeviceArgs{...} }

type InstanceBlockDeviceArrayOutput 

type InstanceBlockDeviceArrayOutput struct{ *pulumi.OutputState }

func (InstanceBlockDeviceArrayOutput) ElementType 

func (InstanceBlockDeviceArrayOutput) ElementType() reflect.Type

func (InstanceBlockDeviceArrayOutput) Index 

func (o InstanceBlockDeviceArrayOutput) Index(i pulumi.IntInput) InstanceBlockDeviceOutput

func (InstanceBlockDeviceArrayOutput) ToInstanceBlockDeviceArrayOutput 

func (o InstanceBlockDeviceArrayOutput) ToInstanceBlockDeviceArrayOutput() InstanceBlockDeviceArrayOutput

func (InstanceBlockDeviceArrayOutput) ToInstanceBlockDeviceArrayOutputWithContext 

func (o InstanceBlockDeviceArrayOutput) ToInstanceBlockDeviceArrayOutputWithContext(ctx context.Context) InstanceBlockDeviceArrayOutput

type InstanceBlockDeviceInput 

type InstanceBlockDeviceInput interface {
	pulumi.Input

	ToInstanceBlockDeviceOutput() InstanceBlockDeviceOutput
	ToInstanceBlockDeviceOutputWithContext(context.Context) InstanceBlockDeviceOutput
}

InstanceBlockDeviceInput is an input type that accepts InstanceBlockDeviceArgs and InstanceBlockDeviceOutput values. You can construct a concrete instance of `InstanceBlockDeviceInput` via: 

InstanceBlockDeviceArgs{...}

type InstanceBlockDeviceOutput 

type InstanceBlockDeviceOutput struct{ *pulumi.OutputState }

func (InstanceBlockDeviceOutput) BootIndex 

func (o InstanceBlockDeviceOutput) BootIndex() pulumi.IntPtrOutput

The boot index of the volume. It defaults to 0. Changing this creates a new server.

func (InstanceBlockDeviceOutput) DeleteOnTermination 

func (o InstanceBlockDeviceOutput) DeleteOnTermination() pulumi.BoolPtrOutput

Delete the volume / block device upon termination of the instance. Defaults to false. Changing this creates a new server.

func (InstanceBlockDeviceOutput) DestinationType 

func (o InstanceBlockDeviceOutput) DestinationType() pulumi.StringPtrOutput

The type that gets created. Possible values are "volume" and "local". Changing this creates a new server.

func (InstanceBlockDeviceOutput) DeviceType 

func (o InstanceBlockDeviceOutput) DeviceType() pulumi.StringPtrOutput

The low-level device type that will be used. Most common thing is to leave this empty. Changing this creates a new server.

func (InstanceBlockDeviceOutput) DiskBus 

func (o InstanceBlockDeviceOutput) DiskBus() pulumi.StringPtrOutput

The low-level disk bus that will be used. Most common thing is to leave this empty. Changing this creates a new server.

func (InstanceBlockDeviceOutput) ElementType 

func (InstanceBlockDeviceOutput) ElementType() reflect.Type

func (InstanceBlockDeviceOutput) GuestFormat 

func (o InstanceBlockDeviceOutput) GuestFormat() pulumi.StringPtrOutput

Specifies the guest server disk file system format, such as `ext2`, `ext3`, `ext4`, `xfs` or `swap`. Swap block device mappings have the following restrictions: sourceType must be blank and destinationType must be local and only one swap disk per server and the size of the swap disk must be less than or equal to the swap size of the flavor. Changing this creates a new server.

func (InstanceBlockDeviceOutput) SourceType 

func (o InstanceBlockDeviceOutput) SourceType() pulumi.StringOutput

The source type of the device. Must be one of "blank", "image", "volume", or "snapshot". Changing this creates a new server.

func (InstanceBlockDeviceOutput) ToInstanceBlockDeviceOutput 

func (o InstanceBlockDeviceOutput) ToInstanceBlockDeviceOutput() InstanceBlockDeviceOutput

func (InstanceBlockDeviceOutput) ToInstanceBlockDeviceOutputWithContext 

func (o InstanceBlockDeviceOutput) ToInstanceBlockDeviceOutputWithContext(ctx context.Context) InstanceBlockDeviceOutput

func (InstanceBlockDeviceOutput) Uuid 

func (o InstanceBlockDeviceOutput) Uuid() pulumi.StringPtrOutput

The UUID of the image, volume, or snapshot. Changing this creates a new server.

func (InstanceBlockDeviceOutput) VolumeSize 

func (o InstanceBlockDeviceOutput) VolumeSize() pulumi.IntPtrOutput

The size of the volume to create (in gigabytes). Required in the following combinations: source=image and destination=volume, source=blank and destination=local, and source=blank and destination=volume. Changing this creates a new server.

func (InstanceBlockDeviceOutput) VolumeType 

func (o InstanceBlockDeviceOutput) VolumeType() pulumi.StringPtrOutput

The volume type that will be used, for example SSD or HDD storage. The available options depend on how your specific OpenStack cloud is configured and what classes of storage are provided. Changing this creates a new server.

type InstanceInput added in v2.10.0 

type InstanceInput interface {
	pulumi.Input

	ToInstanceOutput() InstanceOutput
	ToInstanceOutputWithContext(ctx context.Context) InstanceOutput
}

type InstanceMap added in v2.14.1 

type InstanceMap map[string]InstanceInput

func (InstanceMap) ElementType added in v2.14.1 

func (InstanceMap) ElementType() reflect.Type

func (InstanceMap) ToInstanceMapOutput added in v2.14.1 

func (i InstanceMap) ToInstanceMapOutput() InstanceMapOutput

func (InstanceMap) ToInstanceMapOutputWithContext added in v2.14.1 

func (i InstanceMap) ToInstanceMapOutputWithContext(ctx context.Context) InstanceMapOutput

type InstanceMapInput added in v2.14.1 

type InstanceMapInput interface {
	pulumi.Input

	ToInstanceMapOutput() InstanceMapOutput
	ToInstanceMapOutputWithContext(context.Context) InstanceMapOutput
}

InstanceMapInput is an input type that accepts InstanceMap and InstanceMapOutput values. You can construct a concrete instance of `InstanceMapInput` via: 

InstanceMap{ "key": InstanceArgs{...} }

type InstanceMapOutput added in v2.14.1 

type InstanceMapOutput struct{ *pulumi.OutputState }

func (InstanceMapOutput) ElementType added in v2.14.1 

func (InstanceMapOutput) ElementType() reflect.Type

func (InstanceMapOutput) MapIndex added in v2.14.1 

func (o InstanceMapOutput) MapIndex(k pulumi.StringInput) InstanceOutput

func (InstanceMapOutput) ToInstanceMapOutput added in v2.14.1 

func (o InstanceMapOutput) ToInstanceMapOutput() InstanceMapOutput

func (InstanceMapOutput) ToInstanceMapOutputWithContext added in v2.14.1 

func (o InstanceMapOutput) ToInstanceMapOutputWithContext(ctx context.Context) InstanceMapOutput

type InstanceNetwork 

type InstanceNetwork struct {
	// Specifies if this network should be used for
	// provisioning access. Accepts true or false. Defaults to false.
	AccessNetwork *bool `pulumi:"accessNetwork"`
	// Specifies a fixed IPv4 address to be used on this
	// network. Changing this creates a new server.
	FixedIpV4  *string `pulumi:"fixedIpV4"`
	FixedIpV6  *string `pulumi:"fixedIpV6"`
	FloatingIp *string `pulumi:"floatingIp"`
	Mac        *string `pulumi:"mac"`
	// The human-readable
	// name of the network. Changing this creates a new server.
	Name *string `pulumi:"name"`
	// The port UUID of a
	// network to attach to the server. Changing this creates a new server.
	Port *string `pulumi:"port"`
	// The UUID of
	// the image, volume, or snapshot. Changing this creates a new server.
	Uuid *string `pulumi:"uuid"`
}

type InstanceNetworkArgs 

type InstanceNetworkArgs struct {
	// Specifies if this network should be used for
	// provisioning access. Accepts true or false. Defaults to false.
	AccessNetwork pulumi.BoolPtrInput `pulumi:"accessNetwork"`
	// Specifies a fixed IPv4 address to be used on this
	// network. Changing this creates a new server.
	FixedIpV4  pulumi.StringPtrInput `pulumi:"fixedIpV4"`
	FixedIpV6  pulumi.StringPtrInput `pulumi:"fixedIpV6"`
	FloatingIp pulumi.StringPtrInput `pulumi:"floatingIp"`
	Mac        pulumi.StringPtrInput `pulumi:"mac"`
	// The human-readable
	// name of the network. Changing this creates a new server.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The port UUID of a
	// network to attach to the server. Changing this creates a new server.
	Port pulumi.StringPtrInput `pulumi:"port"`
	// The UUID of
	// the image, volume, or snapshot. Changing this creates a new server.
	Uuid pulumi.StringPtrInput `pulumi:"uuid"`
}

func (InstanceNetworkArgs) ElementType 

func (InstanceNetworkArgs) ElementType() reflect.Type

func (InstanceNetworkArgs) ToInstanceNetworkOutput 

func (i InstanceNetworkArgs) ToInstanceNetworkOutput() InstanceNetworkOutput

func (InstanceNetworkArgs) ToInstanceNetworkOutputWithContext 

func (i InstanceNetworkArgs) ToInstanceNetworkOutputWithContext(ctx context.Context) InstanceNetworkOutput

type InstanceNetworkArray 

type InstanceNetworkArray []InstanceNetworkInput

func (InstanceNetworkArray) ElementType 

func (InstanceNetworkArray) ElementType() reflect.Type

func (InstanceNetworkArray) ToInstanceNetworkArrayOutput 

func (i InstanceNetworkArray) ToInstanceNetworkArrayOutput() InstanceNetworkArrayOutput

func (InstanceNetworkArray) ToInstanceNetworkArrayOutputWithContext 

func (i InstanceNetworkArray) ToInstanceNetworkArrayOutputWithContext(ctx context.Context) InstanceNetworkArrayOutput

type InstanceNetworkArrayInput 

type InstanceNetworkArrayInput interface {
	pulumi.Input

	ToInstanceNetworkArrayOutput() InstanceNetworkArrayOutput
	ToInstanceNetworkArrayOutputWithContext(context.Context) InstanceNetworkArrayOutput
}

InstanceNetworkArrayInput is an input type that accepts InstanceNetworkArray and InstanceNetworkArrayOutput values. You can construct a concrete instance of `InstanceNetworkArrayInput` via: 

InstanceNetworkArray{ InstanceNetworkArgs{...} }

type InstanceNetworkArrayOutput 

type InstanceNetworkArrayOutput struct{ *pulumi.OutputState }

func (InstanceNetworkArrayOutput) ElementType 

func (InstanceNetworkArrayOutput) ElementType() reflect.Type

func (InstanceNetworkArrayOutput) Index 

func (o InstanceNetworkArrayOutput) Index(i pulumi.IntInput) InstanceNetworkOutput

func (InstanceNetworkArrayOutput) ToInstanceNetworkArrayOutput 

func (o InstanceNetworkArrayOutput) ToInstanceNetworkArrayOutput() InstanceNetworkArrayOutput

func (InstanceNetworkArrayOutput) ToInstanceNetworkArrayOutputWithContext 

func (o InstanceNetworkArrayOutput) ToInstanceNetworkArrayOutputWithContext(ctx context.Context) InstanceNetworkArrayOutput

type InstanceNetworkInput 

type InstanceNetworkInput interface {
	pulumi.Input

	ToInstanceNetworkOutput() InstanceNetworkOutput
	ToInstanceNetworkOutputWithContext(context.Context) InstanceNetworkOutput
}

InstanceNetworkInput is an input type that accepts InstanceNetworkArgs and InstanceNetworkOutput values. You can construct a concrete instance of `InstanceNetworkInput` via: 

InstanceNetworkArgs{...}

type InstanceNetworkOutput 

type InstanceNetworkOutput struct{ *pulumi.OutputState }

func (InstanceNetworkOutput) AccessNetwork 

func (o InstanceNetworkOutput) AccessNetwork() pulumi.BoolPtrOutput

Specifies if this network should be used for provisioning access. Accepts true or false. Defaults to false.

func (InstanceNetworkOutput) ElementType 

func (InstanceNetworkOutput) ElementType() reflect.Type

func (InstanceNetworkOutput) FixedIpV4 

func (o InstanceNetworkOutput) FixedIpV4() pulumi.StringPtrOutput

Specifies a fixed IPv4 address to be used on this network. Changing this creates a new server.

func (InstanceNetworkOutput) FixedIpV6 

func (o InstanceNetworkOutput) FixedIpV6() pulumi.StringPtrOutput

func (InstanceNetworkOutput) FloatingIp added in v2.8.0 

func (o InstanceNetworkOutput) FloatingIp() pulumi.StringPtrOutput

func (InstanceNetworkOutput) Mac 

func (o InstanceNetworkOutput) Mac() pulumi.StringPtrOutput

func (InstanceNetworkOutput) Name 

func (o InstanceNetworkOutput) Name() pulumi.StringPtrOutput

The human-readable name of the network. Changing this creates a new server.

func (InstanceNetworkOutput) Port 

func (o InstanceNetworkOutput) Port() pulumi.StringPtrOutput

The port UUID of a network to attach to the server. Changing this creates a new server.

func (InstanceNetworkOutput) ToInstanceNetworkOutput 

func (o InstanceNetworkOutput) ToInstanceNetworkOutput() InstanceNetworkOutput

func (InstanceNetworkOutput) ToInstanceNetworkOutputWithContext 

func (o InstanceNetworkOutput) ToInstanceNetworkOutputWithContext(ctx context.Context) InstanceNetworkOutput

func (InstanceNetworkOutput) Uuid 

func (o InstanceNetworkOutput) Uuid() pulumi.StringPtrOutput

The UUID of the image, volume, or snapshot. Changing this creates a new server.

type InstanceOutput added in v2.10.0 

type InstanceOutput struct {
	*pulumi.OutputState
}

func (InstanceOutput) ElementType added in v2.10.0 

func (InstanceOutput) ElementType() reflect.Type

func (InstanceOutput) ToInstanceOutput added in v2.10.0 

func (o InstanceOutput) ToInstanceOutput() InstanceOutput

func (InstanceOutput) ToInstanceOutputWithContext added in v2.10.0 

func (o InstanceOutput) ToInstanceOutputWithContext(ctx context.Context) InstanceOutput

func (InstanceOutput) ToInstancePtrOutput added in v2.14.1 

func (o InstanceOutput) ToInstancePtrOutput() InstancePtrOutput

func (InstanceOutput) ToInstancePtrOutputWithContext added in v2.14.1 

func (o InstanceOutput) ToInstancePtrOutputWithContext(ctx context.Context) InstancePtrOutput

type InstancePersonality 

type InstancePersonality struct {
	// The contents of the file. Limited to 255 bytes.
	Content string `pulumi:"content"`
	// The absolute path of the destination file.
	File string `pulumi:"file"`
}

type InstancePersonalityArgs 

type InstancePersonalityArgs struct {
	// The contents of the file. Limited to 255 bytes.
	Content pulumi.StringInput `pulumi:"content"`
	// The absolute path of the destination file.
	File pulumi.StringInput `pulumi:"file"`
}

func (InstancePersonalityArgs) ElementType 

func (InstancePersonalityArgs) ElementType() reflect.Type

func (InstancePersonalityArgs) ToInstancePersonalityOutput 

func (i InstancePersonalityArgs) ToInstancePersonalityOutput() InstancePersonalityOutput

func (InstancePersonalityArgs) ToInstancePersonalityOutputWithContext 

func (i InstancePersonalityArgs) ToInstancePersonalityOutputWithContext(ctx context.Context) InstancePersonalityOutput

type InstancePersonalityArray 

type InstancePersonalityArray []InstancePersonalityInput

func (InstancePersonalityArray) ElementType 

func (InstancePersonalityArray) ElementType() reflect.Type

func (InstancePersonalityArray) ToInstancePersonalityArrayOutput 

func (i InstancePersonalityArray) ToInstancePersonalityArrayOutput() InstancePersonalityArrayOutput

func (InstancePersonalityArray) ToInstancePersonalityArrayOutputWithContext 

func (i InstancePersonalityArray) ToInstancePersonalityArrayOutputWithContext(ctx context.Context) InstancePersonalityArrayOutput

type InstancePersonalityArrayInput 

type InstancePersonalityArrayInput interface {
	pulumi.Input

	ToInstancePersonalityArrayOutput() InstancePersonalityArrayOutput
	ToInstancePersonalityArrayOutputWithContext(context.Context) InstancePersonalityArrayOutput
}

InstancePersonalityArrayInput is an input type that accepts InstancePersonalityArray and InstancePersonalityArrayOutput values. You can construct a concrete instance of `InstancePersonalityArrayInput` via: 

InstancePersonalityArray{ InstancePersonalityArgs{...} }

type InstancePersonalityArrayOutput 

type InstancePersonalityArrayOutput struct{ *pulumi.OutputState }

func (InstancePersonalityArrayOutput) ElementType 

func (InstancePersonalityArrayOutput) ElementType() reflect.Type

func (InstancePersonalityArrayOutput) Index 

func (o InstancePersonalityArrayOutput) Index(i pulumi.IntInput) InstancePersonalityOutput

func (InstancePersonalityArrayOutput) ToInstancePersonalityArrayOutput 

func (o InstancePersonalityArrayOutput) ToInstancePersonalityArrayOutput() InstancePersonalityArrayOutput

func (InstancePersonalityArrayOutput) ToInstancePersonalityArrayOutputWithContext 

func (o InstancePersonalityArrayOutput) ToInstancePersonalityArrayOutputWithContext(ctx context.Context) InstancePersonalityArrayOutput

type InstancePersonalityInput 

type InstancePersonalityInput interface {
	pulumi.Input

	ToInstancePersonalityOutput() InstancePersonalityOutput
	ToInstancePersonalityOutputWithContext(context.Context) InstancePersonalityOutput
}

InstancePersonalityInput is an input type that accepts InstancePersonalityArgs and InstancePersonalityOutput values. You can construct a concrete instance of `InstancePersonalityInput` via: 

InstancePersonalityArgs{...}

type InstancePersonalityOutput 

type InstancePersonalityOutput struct{ *pulumi.OutputState }

func (InstancePersonalityOutput) Content 

func (o InstancePersonalityOutput) Content() pulumi.StringOutput

The contents of the file. Limited to 255 bytes.

func (InstancePersonalityOutput) ElementType 

func (InstancePersonalityOutput) ElementType() reflect.Type

func (InstancePersonalityOutput) File 

func (o InstancePersonalityOutput) File() pulumi.StringOutput

The absolute path of the destination file.

func (InstancePersonalityOutput) ToInstancePersonalityOutput 

func (o InstancePersonalityOutput) ToInstancePersonalityOutput() InstancePersonalityOutput

func (InstancePersonalityOutput) ToInstancePersonalityOutputWithContext 

func (o InstancePersonalityOutput) ToInstancePersonalityOutputWithContext(ctx context.Context) InstancePersonalityOutput

type InstancePtrInput added in v2.14.1 

type InstancePtrInput interface {
	pulumi.Input

	ToInstancePtrOutput() InstancePtrOutput
	ToInstancePtrOutputWithContext(ctx context.Context) InstancePtrOutput
}

type InstancePtrOutput added in v2.14.1 

type InstancePtrOutput struct {
	*pulumi.OutputState
}

func (InstancePtrOutput) ElementType added in v2.14.1 

func (InstancePtrOutput) ElementType() reflect.Type

func (InstancePtrOutput) ToInstancePtrOutput added in v2.14.1 

func (o InstancePtrOutput) ToInstancePtrOutput() InstancePtrOutput

func (InstancePtrOutput) ToInstancePtrOutputWithContext added in v2.14.1 

func (o InstancePtrOutput) ToInstancePtrOutputWithContext(ctx context.Context) InstancePtrOutput

type InstanceSchedulerHint 

type InstanceSchedulerHint struct {
	// Arbitrary key/value pairs of additional
	// properties to pass to the scheduler.
	AdditionalProperties map[string]interface{} `pulumi:"additionalProperties"`
	// An IP Address in CIDR form. The instance
	// will be placed on a compute node that is in the same subnet.
	BuildNearHostIp *string `pulumi:"buildNearHostIp"`
	// The names of cells where not to build the instance.
	DifferentCells []string `pulumi:"differentCells"`
	// A list of instance UUIDs. The instance will
	// be scheduled on a different host than all other instances.
	DifferentHosts []string `pulumi:"differentHosts"`
	// A UUID of a Server Group. The instance will be placed
	// into that group.
	Group *string `pulumi:"group"`
	// A conditional query that a compute node must pass in
	// order to host an instance. The query must use the `JsonFilter` syntax
	// which is described
	// [here](https://docs.openstack.org/nova/latest/admin/configuration/schedulers.html#jsonfilter).
	// At this time, only simple queries are supported. Compound queries using
	// `and`, `or`, or `not` are not supported. An example of a simple query is:
	Queries []string `pulumi:"queries"`
	// A list of instance UUIDs. The instance will be
	// scheduled on the same host of those specified.
	SameHosts []string `pulumi:"sameHosts"`
	// The name of a cell to host the instance.
	TargetCell *string `pulumi:"targetCell"`
}

type InstanceSchedulerHintArgs 

type InstanceSchedulerHintArgs struct {
	// Arbitrary key/value pairs of additional
	// properties to pass to the scheduler.
	AdditionalProperties pulumi.MapInput `pulumi:"additionalProperties"`
	// An IP Address in CIDR form. The instance
	// will be placed on a compute node that is in the same subnet.
	BuildNearHostIp pulumi.StringPtrInput `pulumi:"buildNearHostIp"`
	// The names of cells where not to build the instance.
	DifferentCells pulumi.StringArrayInput `pulumi:"differentCells"`
	// A list of instance UUIDs. The instance will
	// be scheduled on a different host than all other instances.
	DifferentHosts pulumi.StringArrayInput `pulumi:"differentHosts"`
	// A UUID of a Server Group. The instance will be placed
	// into that group.
	Group pulumi.StringPtrInput `pulumi:"group"`
	// A conditional query that a compute node must pass in
	// order to host an instance. The query must use the `JsonFilter` syntax
	// which is described
	// [here](https://docs.openstack.org/nova/latest/admin/configuration/schedulers.html#jsonfilter).
	// At this time, only simple queries are supported. Compound queries using
	// `and`, `or`, or `not` are not supported. An example of a simple query is:
	Queries pulumi.StringArrayInput `pulumi:"queries"`
	// A list of instance UUIDs. The instance will be
	// scheduled on the same host of those specified.
	SameHosts pulumi.StringArrayInput `pulumi:"sameHosts"`
	// The name of a cell to host the instance.
	TargetCell pulumi.StringPtrInput `pulumi:"targetCell"`
}

func (InstanceSchedulerHintArgs) ElementType 

func (InstanceSchedulerHintArgs) ElementType() reflect.Type

func (InstanceSchedulerHintArgs) ToInstanceSchedulerHintOutput 

func (i InstanceSchedulerHintArgs) ToInstanceSchedulerHintOutput() InstanceSchedulerHintOutput

func (InstanceSchedulerHintArgs) ToInstanceSchedulerHintOutputWithContext 

func (i InstanceSchedulerHintArgs) ToInstanceSchedulerHintOutputWithContext(ctx context.Context) InstanceSchedulerHintOutput

type InstanceSchedulerHintArray 

type InstanceSchedulerHintArray []InstanceSchedulerHintInput

func (InstanceSchedulerHintArray) ElementType 

func (InstanceSchedulerHintArray) ElementType() reflect.Type

func (InstanceSchedulerHintArray) ToInstanceSchedulerHintArrayOutput 

func (i InstanceSchedulerHintArray) ToInstanceSchedulerHintArrayOutput() InstanceSchedulerHintArrayOutput

func (InstanceSchedulerHintArray) ToInstanceSchedulerHintArrayOutputWithContext 

func (i InstanceSchedulerHintArray) ToInstanceSchedulerHintArrayOutputWithContext(ctx context.Context) InstanceSchedulerHintArrayOutput

type InstanceSchedulerHintArrayInput 

type InstanceSchedulerHintArrayInput interface {
	pulumi.Input

	ToInstanceSchedulerHintArrayOutput() InstanceSchedulerHintArrayOutput
	ToInstanceSchedulerHintArrayOutputWithContext(context.Context) InstanceSchedulerHintArrayOutput
}

InstanceSchedulerHintArrayInput is an input type that accepts InstanceSchedulerHintArray and InstanceSchedulerHintArrayOutput values. You can construct a concrete instance of `InstanceSchedulerHintArrayInput` via: 

InstanceSchedulerHintArray{ InstanceSchedulerHintArgs{...} }

type InstanceSchedulerHintArrayOutput 

type InstanceSchedulerHintArrayOutput struct{ *pulumi.OutputState }

func (InstanceSchedulerHintArrayOutput) ElementType 

func (InstanceSchedulerHintArrayOutput) ElementType() reflect.Type

func (InstanceSchedulerHintArrayOutput) Index 

func (o InstanceSchedulerHintArrayOutput) Index(i pulumi.IntInput) InstanceSchedulerHintOutput

func (InstanceSchedulerHintArrayOutput) ToInstanceSchedulerHintArrayOutput 

func (o InstanceSchedulerHintArrayOutput) ToInstanceSchedulerHintArrayOutput() InstanceSchedulerHintArrayOutput

func (InstanceSchedulerHintArrayOutput) ToInstanceSchedulerHintArrayOutputWithContext 

func (o InstanceSchedulerHintArrayOutput) ToInstanceSchedulerHintArrayOutputWithContext(ctx context.Context) InstanceSchedulerHintArrayOutput

type InstanceSchedulerHintInput 

type InstanceSchedulerHintInput interface {
	pulumi.Input

	ToInstanceSchedulerHintOutput() InstanceSchedulerHintOutput
	ToInstanceSchedulerHintOutputWithContext(context.Context) InstanceSchedulerHintOutput
}

InstanceSchedulerHintInput is an input type that accepts InstanceSchedulerHintArgs and InstanceSchedulerHintOutput values. You can construct a concrete instance of `InstanceSchedulerHintInput` via: 

InstanceSchedulerHintArgs{...}

type InstanceSchedulerHintOutput 

type InstanceSchedulerHintOutput struct{ *pulumi.OutputState }

func (InstanceSchedulerHintOutput) AdditionalProperties 

func (o InstanceSchedulerHintOutput) AdditionalProperties() pulumi.MapOutput

Arbitrary key/value pairs of additional properties to pass to the scheduler.

func (InstanceSchedulerHintOutput) BuildNearHostIp 

func (o InstanceSchedulerHintOutput) BuildNearHostIp() pulumi.StringPtrOutput

An IP Address in CIDR form. The instance will be placed on a compute node that is in the same subnet.

func (InstanceSchedulerHintOutput) DifferentCells added in v2.9.0 

func (o InstanceSchedulerHintOutput) DifferentCells() pulumi.StringArrayOutput

The names of cells where not to build the instance.

func (InstanceSchedulerHintOutput) DifferentHosts 

func (o InstanceSchedulerHintOutput) DifferentHosts() pulumi.StringArrayOutput

A list of instance UUIDs. The instance will be scheduled on a different host than all other instances.

func (InstanceSchedulerHintOutput) ElementType 

func (InstanceSchedulerHintOutput) ElementType() reflect.Type

func (InstanceSchedulerHintOutput) Group 

func (o InstanceSchedulerHintOutput) Group() pulumi.StringPtrOutput

A UUID of a Server Group. The instance will be placed into that group.

func (InstanceSchedulerHintOutput) Queries 

func (o InstanceSchedulerHintOutput) Queries() pulumi.StringArrayOutput

A conditional query that a compute node must pass in order to host an instance. The query must use the `JsonFilter` syntax which is described [here](https://docs.openstack.org/nova/latest/admin/configuration/schedulers.html#jsonfilter). At this time, only simple queries are supported. Compound queries using `and`, `or`, or `not` are not supported. An example of a simple query is:

func (InstanceSchedulerHintOutput) SameHosts 

func (o InstanceSchedulerHintOutput) SameHosts() pulumi.StringArrayOutput

A list of instance UUIDs. The instance will be scheduled on the same host of those specified.

func (InstanceSchedulerHintOutput) TargetCell 

func (o InstanceSchedulerHintOutput) TargetCell() pulumi.StringPtrOutput

The name of a cell to host the instance.

func (InstanceSchedulerHintOutput) ToInstanceSchedulerHintOutput 

func (o InstanceSchedulerHintOutput) ToInstanceSchedulerHintOutput() InstanceSchedulerHintOutput

func (InstanceSchedulerHintOutput) ToInstanceSchedulerHintOutputWithContext 

func (o InstanceSchedulerHintOutput) ToInstanceSchedulerHintOutputWithContext(ctx context.Context) InstanceSchedulerHintOutput

type InstanceState 

type InstanceState struct {
	// The first detected Fixed IPv4 address.
	AccessIpV4 pulumi.StringPtrInput
	// The first detected Fixed IPv6 address.
	AccessIpV6 pulumi.StringPtrInput
	// The administrative password to assign to the server.
	// Changing this changes the root password on the existing server.
	AdminPass   pulumi.StringPtrInput
	AllMetadata pulumi.MapInput
	// The collection of tags assigned on the instance, which have
	// been explicitly and implicitly added.
	AllTags pulumi.StringArrayInput
	// The availability zone in which to create
	// the server. Conflicts with `availabilityZoneHints`. Changing this creates
	// a new server.
	AvailabilityZone pulumi.StringPtrInput
	// The availability zone in which to
	// create the server. This argument is preferred to `availabilityZone`, when
	// scheduling the server on a
	// [particular](https://docs.openstack.org/nova/latest/admin/availability-zones.html)
	// host or node. Conflicts with `availabilityZone`. Changing this creates a
	// new server.
	AvailabilityZoneHints pulumi.StringPtrInput
	// Configuration of block devices. The blockDevice
	// structure is documented below. Changing this creates a new server.
	// You can specify multiple block devices which will create an instance with
	// multiple disks. This configuration is very flexible, so please see the
	// following [reference](https://docs.openstack.org/nova/latest/user/block-device-mapping.html)
	// for more information.
	BlockDevices InstanceBlockDeviceArrayInput
	// Whether to use the configDrive feature to
	// configure the instance. Changing this creates a new server.
	ConfigDrive pulumi.BoolPtrInput
	// The flavor ID of
	// the desired flavor for the server. Changing this resizes the existing server.
	FlavorId pulumi.StringPtrInput
	// The name of the
	// desired flavor for the server. Changing this resizes the existing server.
	FlavorName pulumi.StringPtrInput
	// Whether to force the OpenStack instance to be
	// forcefully deleted. This is useful for environments that have reclaim / soft
	// deletion enabled.
	ForceDelete pulumi.BoolPtrInput
	// (Optional; Required if `imageName` is empty and not booting
	// from a volume. Do not specify if booting from a volume.) The image ID of
	// the desired image for the server. Changing this creates a new server.
	ImageId pulumi.StringPtrInput
	// (Optional; Required if `imageId` is empty and not booting
	// from a volume. Do not specify if booting from a volume.) The name of the
	// desired image for the server. Changing this creates a new server.
	ImageName pulumi.StringPtrInput
	// The name of a key pair to put on the server. The key
	// pair must already be created and associated with the tenant's account.
	// Changing this creates a new server.
	KeyPair pulumi.StringPtrInput
	// Metadata key/value pairs to make available from
	// within the instance. Changing this updates the existing server metadata.
	Metadata pulumi.MapInput
	// The human-readable
	// name of the network. Changing this creates a new server.
	Name pulumi.StringPtrInput
	// Special string for `network` option to create
	// the server. `networkMode` can be `"auto"` or `"none"`.
	// Please see the following [reference](https://docs.openstack.org/api-ref/compute/?expanded=create-server-detail#id11) for more information. Conflicts with `network`.
	NetworkMode pulumi.StringPtrInput
	// An array of one or more networks to attach to the
	// instance. The network object structure is documented below. Changing this
	// creates a new server.
	Networks InstanceNetworkArrayInput
	// Customize the personality of an instance by
	// defining one or more files and their contents. The personality structure
	// is described below.
	Personalities InstancePersonalityArrayInput
	// Provide the VM state. Only 'active' and 'shutoff'
	// are supported values. *Note*: If the initial powerState is the shutoff
	// the VM will be stopped immediately after build and the provisioners like
	// remote-exec or files are not supported.
	PowerState pulumi.StringPtrInput
	// The region in which to create the server instance. If
	// omitted, the `region` argument of the provider is used. Changing this
	// creates a new server.
	Region pulumi.StringPtrInput
	// Provide the Nova scheduler with hints on how
	// the instance should be launched. The available hints are described below.
	SchedulerHints InstanceSchedulerHintArrayInput
	// An array of one or more security group names
	// to associate with the server. Changing this results in adding/removing
	// security groups from the existing server. *Note*: When attaching the
	// instance to networks using Ports, place the security groups on the Port
	// and not the instance. *Note*: Names should be used and not ids, as ids
	// trigger unnecessary updates.
	SecurityGroups pulumi.StringArrayInput
	// Whether to try stop instance gracefully
	// before destroying it, thus giving chance for guest OS daemons to stop correctly.
	// If instance doesn't stop within timeout, it will be destroyed anyway.
	StopBeforeDestroy pulumi.BoolPtrInput
	// A set of string tags for the instance. Changing this
	// updates the existing instance tags.
	Tags pulumi.StringArrayInput
	// The user data to provide when launching the instance.
	// Changing this creates a new server.
	UserData pulumi.StringPtrInput
	// Map of additional vendor-specific options.
	// Supported options are described below.
	VendorOptions InstanceVendorOptionsPtrInput
}

func (InstanceState) ElementType 

func (InstanceState) ElementType() reflect.Type

type InstanceVendorOptions 

type InstanceVendorOptions struct {
	// Whether to try to detach all attached
	// ports to the vm before destroying it to make sure the port state is correct
	// after the vm destruction. This is helpful when the port is not deleted.
	DetachPortsBeforeDestroy *bool `pulumi:"detachPortsBeforeDestroy"`
	// Boolean to control whether
	// to ignore manual confirmation of the instance resizing. This can be helpful
	// to work with some OpenStack clouds which automatically confirm resizing of
	// instances after some timeout.
	IgnoreResizeConfirmation *bool `pulumi:"ignoreResizeConfirmation"`
}

type InstanceVendorOptionsArgs 

type InstanceVendorOptionsArgs struct {
	// Whether to try to detach all attached
	// ports to the vm before destroying it to make sure the port state is correct
	// after the vm destruction. This is helpful when the port is not deleted.
	DetachPortsBeforeDestroy pulumi.BoolPtrInput `pulumi:"detachPortsBeforeDestroy"`
	// Boolean to control whether
	// to ignore manual confirmation of the instance resizing. This can be helpful
	// to work with some OpenStack clouds which automatically confirm resizing of
	// instances after some timeout.
	IgnoreResizeConfirmation pulumi.BoolPtrInput `pulumi:"ignoreResizeConfirmation"`
}

func (InstanceVendorOptionsArgs) ElementType 

func (InstanceVendorOptionsArgs) ElementType() reflect.Type

func (InstanceVendorOptionsArgs) ToInstanceVendorOptionsOutput 

func (i InstanceVendorOptionsArgs) ToInstanceVendorOptionsOutput() InstanceVendorOptionsOutput

func (InstanceVendorOptionsArgs) ToInstanceVendorOptionsOutputWithContext 

func (i InstanceVendorOptionsArgs) ToInstanceVendorOptionsOutputWithContext(ctx context.Context) InstanceVendorOptionsOutput

func (InstanceVendorOptionsArgs) ToInstanceVendorOptionsPtrOutput 

func (i InstanceVendorOptionsArgs) ToInstanceVendorOptionsPtrOutput() InstanceVendorOptionsPtrOutput

func (InstanceVendorOptionsArgs) ToInstanceVendorOptionsPtrOutputWithContext 

func (i InstanceVendorOptionsArgs) ToInstanceVendorOptionsPtrOutputWithContext(ctx context.Context) InstanceVendorOptionsPtrOutput

type InstanceVendorOptionsInput 

type InstanceVendorOptionsInput interface {
	pulumi.Input

	ToInstanceVendorOptionsOutput() InstanceVendorOptionsOutput
	ToInstanceVendorOptionsOutputWithContext(context.Context) InstanceVendorOptionsOutput
}

InstanceVendorOptionsInput is an input type that accepts InstanceVendorOptionsArgs and InstanceVendorOptionsOutput values. You can construct a concrete instance of `InstanceVendorOptionsInput` via: 

InstanceVendorOptionsArgs{...}

type InstanceVendorOptionsOutput 

type InstanceVendorOptionsOutput struct{ *pulumi.OutputState }

func (InstanceVendorOptionsOutput) DetachPortsBeforeDestroy added in v2.2.0 

func (o InstanceVendorOptionsOutput) DetachPortsBeforeDestroy() pulumi.BoolPtrOutput

Whether to try to detach all attached ports to the vm before destroying it to make sure the port state is correct after the vm destruction. This is helpful when the port is not deleted.

func (InstanceVendorOptionsOutput) ElementType 

func (InstanceVendorOptionsOutput) ElementType() reflect.Type

func (InstanceVendorOptionsOutput) IgnoreResizeConfirmation 

func (o InstanceVendorOptionsOutput) IgnoreResizeConfirmation() pulumi.BoolPtrOutput

Boolean to control whether to ignore manual confirmation of the instance resizing. This can be helpful to work with some OpenStack clouds which automatically confirm resizing of instances after some timeout.

func (InstanceVendorOptionsOutput) ToInstanceVendorOptionsOutput 

func (o InstanceVendorOptionsOutput) ToInstanceVendorOptionsOutput() InstanceVendorOptionsOutput

func (InstanceVendorOptionsOutput) ToInstanceVendorOptionsOutputWithContext 

func (o InstanceVendorOptionsOutput) ToInstanceVendorOptionsOutputWithContext(ctx context.Context) InstanceVendorOptionsOutput

func (InstanceVendorOptionsOutput) ToInstanceVendorOptionsPtrOutput 

func (o InstanceVendorOptionsOutput) ToInstanceVendorOptionsPtrOutput() InstanceVendorOptionsPtrOutput

func (InstanceVendorOptionsOutput) ToInstanceVendorOptionsPtrOutputWithContext 

func (o InstanceVendorOptionsOutput) ToInstanceVendorOptionsPtrOutputWithContext(ctx context.Context) InstanceVendorOptionsPtrOutput

type InstanceVendorOptionsPtrInput 

type InstanceVendorOptionsPtrInput interface {
	pulumi.Input

	ToInstanceVendorOptionsPtrOutput() InstanceVendorOptionsPtrOutput
	ToInstanceVendorOptionsPtrOutputWithContext(context.Context) InstanceVendorOptionsPtrOutput
}

InstanceVendorOptionsPtrInput is an input type that accepts InstanceVendorOptionsArgs, InstanceVendorOptionsPtr and InstanceVendorOptionsPtrOutput values. You can construct a concrete instance of `InstanceVendorOptionsPtrInput` via: 

        InstanceVendorOptionsArgs{...}

or:

        nil

func InstanceVendorOptionsPtr 

func InstanceVendorOptionsPtr(v *InstanceVendorOptionsArgs) InstanceVendorOptionsPtrInput

type InstanceVendorOptionsPtrOutput 

type InstanceVendorOptionsPtrOutput struct{ *pulumi.OutputState }

func (InstanceVendorOptionsPtrOutput) DetachPortsBeforeDestroy added in v2.2.0 

func (o InstanceVendorOptionsPtrOutput) DetachPortsBeforeDestroy() pulumi.BoolPtrOutput

Whether to try to detach all attached ports to the vm before destroying it to make sure the port state is correct after the vm destruction. This is helpful when the port is not deleted.

func (InstanceVendorOptionsPtrOutput) Elem 

func (o InstanceVendorOptionsPtrOutput) Elem() InstanceVendorOptionsOutput

func (InstanceVendorOptionsPtrOutput) ElementType 

func (InstanceVendorOptionsPtrOutput) ElementType() reflect.Type

func (InstanceVendorOptionsPtrOutput) IgnoreResizeConfirmation 

func (o InstanceVendorOptionsPtrOutput) IgnoreResizeConfirmation() pulumi.BoolPtrOutput

Boolean to control whether to ignore manual confirmation of the instance resizing. This can be helpful to work with some OpenStack clouds which automatically confirm resizing of instances after some timeout.

func (InstanceVendorOptionsPtrOutput) ToInstanceVendorOptionsPtrOutput 

func (o InstanceVendorOptionsPtrOutput) ToInstanceVendorOptionsPtrOutput() InstanceVendorOptionsPtrOutput

func (InstanceVendorOptionsPtrOutput) ToInstanceVendorOptionsPtrOutputWithContext 

func (o InstanceVendorOptionsPtrOutput) ToInstanceVendorOptionsPtrOutputWithContext(ctx context.Context) InstanceVendorOptionsPtrOutput

type InterfaceAttach 

type InterfaceAttach struct {
	pulumi.CustomResourceState

	// An IP address to assosciate with the port.
	// _NOTE_: This option cannot be used with port_id. You must specifiy a network_id. The IP address must lie in a range on the supplied network.
	FixedIp pulumi.StringOutput `pulumi:"fixedIp"`
	// The ID of the Instance to attach the Port or Network to.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
	// The ID of the Network to attach to an Instance. A port will be created automatically.
	// _NOTE_: This option and `portId` are mutually exclusive.
	NetworkId pulumi.StringOutput `pulumi:"networkId"`
	// The ID of the Port to attach to an Instance.
	// _NOTE_: This option and `networkId` are mutually exclusive.
	PortId pulumi.StringOutput `pulumi:"portId"`
	// The region in which to create the interface attachment.
	// If omitted, the `region` argument of the provider is used. Changing this
	// creates a new attachment.
	Region pulumi.StringOutput `pulumi:"region"`
}

Attaches a Network Interface (a Port) to an Instance using the OpenStack Compute (Nova) v2 API.

## Example Usage ### Basic Attachment

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/networking"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networking.NewNetwork(ctx, "network1", &networking.NetworkArgs{
			AdminStateUp: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewInterfaceAttach(ctx, "ai1", &compute.InterfaceAttachArgs{
			InstanceId: instance1.ID(),
			NetworkId:  pulumi.Any(openstack_networking_port_v2.Network_1.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Attachment Specifying a Fixed IP

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/networking"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networking.NewNetwork(ctx, "network1", &networking.NetworkArgs{
			AdminStateUp: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewInterfaceAttach(ctx, "ai1", &compute.InterfaceAttachArgs{
			FixedIp:    pulumi.String("10.0.10.10"),
			InstanceId: instance1.ID(),
			NetworkId:  pulumi.Any(openstack_networking_port_v2.Network_1.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Attachment Using an Existing Port

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/networking"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		network1, err := networking.NewNetwork(ctx, "network1", &networking.NetworkArgs{
			AdminStateUp: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		port1, err := networking.NewPort(ctx, "port1", &networking.PortArgs{
			AdminStateUp: pulumi.Bool(true),
			NetworkId:    network1.ID(),
		})
		if err != nil {
			return err
		}
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewInterfaceAttach(ctx, "ai1", &compute.InterfaceAttachArgs{
			InstanceId: instance1.ID(),
			PortId:     port1.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Interface Attachments can be imported using the Instance ID and Port ID separated by a slash, e.g.

```sh 

$ pulumi import openstack:compute/interfaceAttach:InterfaceAttach ai_1 89c60255-9bd6-460c-822a-e2b959ede9d2/45670584-225f-46c3-b33e-6707b589b666

```

func GetInterfaceAttach 

func GetInterfaceAttach(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InterfaceAttachState, opts ...pulumi.ResourceOption) (*InterfaceAttach, error)

GetInterfaceAttach gets an existing InterfaceAttach resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInterfaceAttach 

func NewInterfaceAttach(ctx *pulumi.Context,
	name string, args *InterfaceAttachArgs, opts ...pulumi.ResourceOption) (*InterfaceAttach, error)

NewInterfaceAttach registers a new resource with the given unique name, arguments, and options.

func (*InterfaceAttach) ElementType added in v2.10.0 

func (*InterfaceAttach) ElementType() reflect.Type

func (*InterfaceAttach) ToInterfaceAttachOutput added in v2.10.0 

func (i *InterfaceAttach) ToInterfaceAttachOutput() InterfaceAttachOutput

func (*InterfaceAttach) ToInterfaceAttachOutputWithContext added in v2.10.0 

func (i *InterfaceAttach) ToInterfaceAttachOutputWithContext(ctx context.Context) InterfaceAttachOutput

func (*InterfaceAttach) ToInterfaceAttachPtrOutput added in v2.14.1 

func (i *InterfaceAttach) ToInterfaceAttachPtrOutput() InterfaceAttachPtrOutput

func (*InterfaceAttach) ToInterfaceAttachPtrOutputWithContext added in v2.14.1 

func (i *InterfaceAttach) ToInterfaceAttachPtrOutputWithContext(ctx context.Context) InterfaceAttachPtrOutput

type InterfaceAttachArgs 

type InterfaceAttachArgs struct {
	// An IP address to assosciate with the port.
	// _NOTE_: This option cannot be used with port_id. You must specifiy a network_id. The IP address must lie in a range on the supplied network.
	FixedIp pulumi.StringPtrInput
	// The ID of the Instance to attach the Port or Network to.
	InstanceId pulumi.StringInput
	// The ID of the Network to attach to an Instance. A port will be created automatically.
	// _NOTE_: This option and `portId` are mutually exclusive.
	NetworkId pulumi.StringPtrInput
	// The ID of the Port to attach to an Instance.
	// _NOTE_: This option and `networkId` are mutually exclusive.
	PortId pulumi.StringPtrInput
	// The region in which to create the interface attachment.
	// If omitted, the `region` argument of the provider is used. Changing this
	// creates a new attachment.
	Region pulumi.StringPtrInput
}

The set of arguments for constructing a InterfaceAttach resource.

func (InterfaceAttachArgs) ElementType 

func (InterfaceAttachArgs) ElementType() reflect.Type

type InterfaceAttachArray added in v2.14.1 

type InterfaceAttachArray []InterfaceAttachInput

func (InterfaceAttachArray) ElementType added in v2.14.1 

func (InterfaceAttachArray) ElementType() reflect.Type

func (InterfaceAttachArray) ToInterfaceAttachArrayOutput added in v2.14.1 

func (i InterfaceAttachArray) ToInterfaceAttachArrayOutput() InterfaceAttachArrayOutput

func (InterfaceAttachArray) ToInterfaceAttachArrayOutputWithContext added in v2.14.1 

func (i InterfaceAttachArray) ToInterfaceAttachArrayOutputWithContext(ctx context.Context) InterfaceAttachArrayOutput

type InterfaceAttachArrayInput added in v2.14.1 

type InterfaceAttachArrayInput interface {
	pulumi.Input

	ToInterfaceAttachArrayOutput() InterfaceAttachArrayOutput
	ToInterfaceAttachArrayOutputWithContext(context.Context) InterfaceAttachArrayOutput
}

InterfaceAttachArrayInput is an input type that accepts InterfaceAttachArray and InterfaceAttachArrayOutput values. You can construct a concrete instance of `InterfaceAttachArrayInput` via: 

InterfaceAttachArray{ InterfaceAttachArgs{...} }

type InterfaceAttachArrayOutput added in v2.14.1 

type InterfaceAttachArrayOutput struct{ *pulumi.OutputState }

func (InterfaceAttachArrayOutput) ElementType added in v2.14.1 

func (InterfaceAttachArrayOutput) ElementType() reflect.Type

func (InterfaceAttachArrayOutput) Index added in v2.14.1 

func (o InterfaceAttachArrayOutput) Index(i pulumi.IntInput) InterfaceAttachOutput

func (InterfaceAttachArrayOutput) ToInterfaceAttachArrayOutput added in v2.14.1 

func (o InterfaceAttachArrayOutput) ToInterfaceAttachArrayOutput() InterfaceAttachArrayOutput

func (InterfaceAttachArrayOutput) ToInterfaceAttachArrayOutputWithContext added in v2.14.1 

func (o InterfaceAttachArrayOutput) ToInterfaceAttachArrayOutputWithContext(ctx context.Context) InterfaceAttachArrayOutput

type InterfaceAttachInput added in v2.10.0 

type InterfaceAttachInput interface {
	pulumi.Input

	ToInterfaceAttachOutput() InterfaceAttachOutput
	ToInterfaceAttachOutputWithContext(ctx context.Context) InterfaceAttachOutput
}

type InterfaceAttachMap added in v2.14.1 

type InterfaceAttachMap map[string]InterfaceAttachInput

func (InterfaceAttachMap) ElementType added in v2.14.1 

func (InterfaceAttachMap) ElementType() reflect.Type

func (InterfaceAttachMap) ToInterfaceAttachMapOutput added in v2.14.1 

func (i InterfaceAttachMap) ToInterfaceAttachMapOutput() InterfaceAttachMapOutput

func (InterfaceAttachMap) ToInterfaceAttachMapOutputWithContext added in v2.14.1 

func (i InterfaceAttachMap) ToInterfaceAttachMapOutputWithContext(ctx context.Context) InterfaceAttachMapOutput

type InterfaceAttachMapInput added in v2.14.1 

type InterfaceAttachMapInput interface {
	pulumi.Input

	ToInterfaceAttachMapOutput() InterfaceAttachMapOutput
	ToInterfaceAttachMapOutputWithContext(context.Context) InterfaceAttachMapOutput
}

InterfaceAttachMapInput is an input type that accepts InterfaceAttachMap and InterfaceAttachMapOutput values. You can construct a concrete instance of `InterfaceAttachMapInput` via: 

InterfaceAttachMap{ "key": InterfaceAttachArgs{...} }

type InterfaceAttachMapOutput added in v2.14.1 

type InterfaceAttachMapOutput struct{ *pulumi.OutputState }

func (InterfaceAttachMapOutput) ElementType added in v2.14.1 

func (InterfaceAttachMapOutput) ElementType() reflect.Type

func (InterfaceAttachMapOutput) MapIndex added in v2.14.1 

func (o InterfaceAttachMapOutput) MapIndex(k pulumi.StringInput) InterfaceAttachOutput

func (InterfaceAttachMapOutput) ToInterfaceAttachMapOutput added in v2.14.1 

func (o InterfaceAttachMapOutput) ToInterfaceAttachMapOutput() InterfaceAttachMapOutput

func (InterfaceAttachMapOutput) ToInterfaceAttachMapOutputWithContext added in v2.14.1 

func (o InterfaceAttachMapOutput) ToInterfaceAttachMapOutputWithContext(ctx context.Context) InterfaceAttachMapOutput

type InterfaceAttachOutput added in v2.10.0 

type InterfaceAttachOutput struct {
	*pulumi.OutputState
}

func (InterfaceAttachOutput) ElementType added in v2.10.0 

func (InterfaceAttachOutput) ElementType() reflect.Type

func (InterfaceAttachOutput) ToInterfaceAttachOutput added in v2.10.0 

func (o InterfaceAttachOutput) ToInterfaceAttachOutput() InterfaceAttachOutput

func (InterfaceAttachOutput) ToInterfaceAttachOutputWithContext added in v2.10.0 

func (o InterfaceAttachOutput) ToInterfaceAttachOutputWithContext(ctx context.Context) InterfaceAttachOutput

func (InterfaceAttachOutput) ToInterfaceAttachPtrOutput added in v2.14.1 

func (o InterfaceAttachOutput) ToInterfaceAttachPtrOutput() InterfaceAttachPtrOutput

func (InterfaceAttachOutput) ToInterfaceAttachPtrOutputWithContext added in v2.14.1 

func (o InterfaceAttachOutput) ToInterfaceAttachPtrOutputWithContext(ctx context.Context) InterfaceAttachPtrOutput

type InterfaceAttachPtrInput added in v2.14.1 

type InterfaceAttachPtrInput interface {
	pulumi.Input

	ToInterfaceAttachPtrOutput() InterfaceAttachPtrOutput
	ToInterfaceAttachPtrOutputWithContext(ctx context.Context) InterfaceAttachPtrOutput
}

type InterfaceAttachPtrOutput added in v2.14.1 

type InterfaceAttachPtrOutput struct {
	*pulumi.OutputState
}

func (InterfaceAttachPtrOutput) ElementType added in v2.14.1 

func (InterfaceAttachPtrOutput) ElementType() reflect.Type

func (InterfaceAttachPtrOutput) ToInterfaceAttachPtrOutput added in v2.14.1 

func (o InterfaceAttachPtrOutput) ToInterfaceAttachPtrOutput() InterfaceAttachPtrOutput

func (InterfaceAttachPtrOutput) ToInterfaceAttachPtrOutputWithContext added in v2.14.1 

func (o InterfaceAttachPtrOutput) ToInterfaceAttachPtrOutputWithContext(ctx context.Context) InterfaceAttachPtrOutput

type InterfaceAttachState 

type InterfaceAttachState struct {
	// An IP address to assosciate with the port.
	// _NOTE_: This option cannot be used with port_id. You must specifiy a network_id. The IP address must lie in a range on the supplied network.
	FixedIp pulumi.StringPtrInput
	// The ID of the Instance to attach the Port or Network to.
	InstanceId pulumi.StringPtrInput
	// The ID of the Network to attach to an Instance. A port will be created automatically.
	// _NOTE_: This option and `portId` are mutually exclusive.
	NetworkId pulumi.StringPtrInput
	// The ID of the Port to attach to an Instance.
	// _NOTE_: This option and `networkId` are mutually exclusive.
	PortId pulumi.StringPtrInput
	// The region in which to create the interface attachment.
	// If omitted, the `region` argument of the provider is used. Changing this
	// creates a new attachment.
	Region pulumi.StringPtrInput
}

func (InterfaceAttachState) ElementType 

func (InterfaceAttachState) ElementType() reflect.Type

type Keypair 

type Keypair struct {
	pulumi.CustomResourceState

	// The fingerprint of the public key.
	Fingerprint pulumi.StringOutput `pulumi:"fingerprint"`
	// A unique name for the keypair. Changing this creates a new
	// keypair.
	Name pulumi.StringOutput `pulumi:"name"`
	// The generated private key when no public key is specified.
	PrivateKey pulumi.StringOutput `pulumi:"privateKey"`
	// A pregenerated OpenSSH-formatted public key.
	// Changing this creates a new keypair. If a public key is not specified, then
	// a public/private key pair will be automatically generated. If a pair is
	// created, then destroying this resource means you will lose access to that
	// keypair forever.
	PublicKey pulumi.StringOutput `pulumi:"publicKey"`
	// The region in which to obtain the V2 Compute client.
	// Keypairs are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new keypair.
	Region pulumi.StringOutput `pulumi:"region"`
	// Map of additional options.
	ValueSpecs pulumi.MapOutput `pulumi:"valueSpecs"`
}

## Import

Keypairs can be imported using the `name`, e.g.

```sh 

$ pulumi import openstack:compute/keypair:Keypair my-keypair test-keypair

```

func GetKeypair 

func GetKeypair(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *KeypairState, opts ...pulumi.ResourceOption) (*Keypair, error)

GetKeypair gets an existing Keypair resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewKeypair 

func NewKeypair(ctx *pulumi.Context,
	name string, args *KeypairArgs, opts ...pulumi.ResourceOption) (*Keypair, error)

NewKeypair registers a new resource with the given unique name, arguments, and options.

func (*Keypair) ElementType added in v2.10.0 

func (*Keypair) ElementType() reflect.Type

func (*Keypair) ToKeypairOutput added in v2.10.0 

func (i *Keypair) ToKeypairOutput() KeypairOutput

func (*Keypair) ToKeypairOutputWithContext added in v2.10.0 

func (i *Keypair) ToKeypairOutputWithContext(ctx context.Context) KeypairOutput

func (*Keypair) ToKeypairPtrOutput added in v2.14.1 

func (i *Keypair) ToKeypairPtrOutput() KeypairPtrOutput

func (*Keypair) ToKeypairPtrOutputWithContext added in v2.14.1 

func (i *Keypair) ToKeypairPtrOutputWithContext(ctx context.Context) KeypairPtrOutput

type KeypairArgs 

type KeypairArgs struct {
	// A unique name for the keypair. Changing this creates a new
	// keypair.
	Name pulumi.StringPtrInput
	// A pregenerated OpenSSH-formatted public key.
	// Changing this creates a new keypair. If a public key is not specified, then
	// a public/private key pair will be automatically generated. If a pair is
	// created, then destroying this resource means you will lose access to that
	// keypair forever.
	PublicKey pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// Keypairs are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new keypair.
	Region pulumi.StringPtrInput
	// Map of additional options.
	ValueSpecs pulumi.MapInput
}

The set of arguments for constructing a Keypair resource.

func (KeypairArgs) ElementType 

func (KeypairArgs) ElementType() reflect.Type

type KeypairArray added in v2.14.1 

type KeypairArray []KeypairInput

func (KeypairArray) ElementType added in v2.14.1 

func (KeypairArray) ElementType() reflect.Type

func (KeypairArray) ToKeypairArrayOutput added in v2.14.1 

func (i KeypairArray) ToKeypairArrayOutput() KeypairArrayOutput

func (KeypairArray) ToKeypairArrayOutputWithContext added in v2.14.1 

func (i KeypairArray) ToKeypairArrayOutputWithContext(ctx context.Context) KeypairArrayOutput

type KeypairArrayInput added in v2.14.1 

type KeypairArrayInput interface {
	pulumi.Input

	ToKeypairArrayOutput() KeypairArrayOutput
	ToKeypairArrayOutputWithContext(context.Context) KeypairArrayOutput
}

KeypairArrayInput is an input type that accepts KeypairArray and KeypairArrayOutput values. You can construct a concrete instance of `KeypairArrayInput` via: 

KeypairArray{ KeypairArgs{...} }

type KeypairArrayOutput added in v2.14.1 

type KeypairArrayOutput struct{ *pulumi.OutputState }

func (KeypairArrayOutput) ElementType added in v2.14.1 

func (KeypairArrayOutput) ElementType() reflect.Type

func (KeypairArrayOutput) Index added in v2.14.1 

func (o KeypairArrayOutput) Index(i pulumi.IntInput) KeypairOutput

func (KeypairArrayOutput) ToKeypairArrayOutput added in v2.14.1 

func (o KeypairArrayOutput) ToKeypairArrayOutput() KeypairArrayOutput

func (KeypairArrayOutput) ToKeypairArrayOutputWithContext added in v2.14.1 

func (o KeypairArrayOutput) ToKeypairArrayOutputWithContext(ctx context.Context) KeypairArrayOutput

type KeypairInput added in v2.10.0 

type KeypairInput interface {
	pulumi.Input

	ToKeypairOutput() KeypairOutput
	ToKeypairOutputWithContext(ctx context.Context) KeypairOutput
}

type KeypairMap added in v2.14.1 

type KeypairMap map[string]KeypairInput

func (KeypairMap) ElementType added in v2.14.1 

func (KeypairMap) ElementType() reflect.Type

func (KeypairMap) ToKeypairMapOutput added in v2.14.1 

func (i KeypairMap) ToKeypairMapOutput() KeypairMapOutput

func (KeypairMap) ToKeypairMapOutputWithContext added in v2.14.1 

func (i KeypairMap) ToKeypairMapOutputWithContext(ctx context.Context) KeypairMapOutput

type KeypairMapInput added in v2.14.1 

type KeypairMapInput interface {
	pulumi.Input

	ToKeypairMapOutput() KeypairMapOutput
	ToKeypairMapOutputWithContext(context.Context) KeypairMapOutput
}

KeypairMapInput is an input type that accepts KeypairMap and KeypairMapOutput values. You can construct a concrete instance of `KeypairMapInput` via: 

KeypairMap{ "key": KeypairArgs{...} }

type KeypairMapOutput added in v2.14.1 

type KeypairMapOutput struct{ *pulumi.OutputState }

func (KeypairMapOutput) ElementType added in v2.14.1 

func (KeypairMapOutput) ElementType() reflect.Type

func (KeypairMapOutput) MapIndex added in v2.14.1 

func (o KeypairMapOutput) MapIndex(k pulumi.StringInput) KeypairOutput

func (KeypairMapOutput) ToKeypairMapOutput added in v2.14.1 

func (o KeypairMapOutput) ToKeypairMapOutput() KeypairMapOutput

func (KeypairMapOutput) ToKeypairMapOutputWithContext added in v2.14.1 

func (o KeypairMapOutput) ToKeypairMapOutputWithContext(ctx context.Context) KeypairMapOutput

type KeypairOutput added in v2.10.0 

type KeypairOutput struct {
	*pulumi.OutputState
}

func (KeypairOutput) ElementType added in v2.10.0 

func (KeypairOutput) ElementType() reflect.Type

func (KeypairOutput) ToKeypairOutput added in v2.10.0 

func (o KeypairOutput) ToKeypairOutput() KeypairOutput

func (KeypairOutput) ToKeypairOutputWithContext added in v2.10.0 

func (o KeypairOutput) ToKeypairOutputWithContext(ctx context.Context) KeypairOutput

func (KeypairOutput) ToKeypairPtrOutput added in v2.14.1 

func (o KeypairOutput) ToKeypairPtrOutput() KeypairPtrOutput

func (KeypairOutput) ToKeypairPtrOutputWithContext added in v2.14.1 

func (o KeypairOutput) ToKeypairPtrOutputWithContext(ctx context.Context) KeypairPtrOutput

type KeypairPtrInput added in v2.14.1 

type KeypairPtrInput interface {
	pulumi.Input

	ToKeypairPtrOutput() KeypairPtrOutput
	ToKeypairPtrOutputWithContext(ctx context.Context) KeypairPtrOutput
}

type KeypairPtrOutput added in v2.14.1 

type KeypairPtrOutput struct {
	*pulumi.OutputState
}

func (KeypairPtrOutput) ElementType added in v2.14.1 

func (KeypairPtrOutput) ElementType() reflect.Type

func (KeypairPtrOutput) ToKeypairPtrOutput added in v2.14.1 

func (o KeypairPtrOutput) ToKeypairPtrOutput() KeypairPtrOutput

func (KeypairPtrOutput) ToKeypairPtrOutputWithContext added in v2.14.1 

func (o KeypairPtrOutput) ToKeypairPtrOutputWithContext(ctx context.Context) KeypairPtrOutput

type KeypairState 

type KeypairState struct {
	// The fingerprint of the public key.
	Fingerprint pulumi.StringPtrInput
	// A unique name for the keypair. Changing this creates a new
	// keypair.
	Name pulumi.StringPtrInput
	// The generated private key when no public key is specified.
	PrivateKey pulumi.StringPtrInput
	// A pregenerated OpenSSH-formatted public key.
	// Changing this creates a new keypair. If a public key is not specified, then
	// a public/private key pair will be automatically generated. If a pair is
	// created, then destroying this resource means you will lose access to that
	// keypair forever.
	PublicKey pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// Keypairs are associated with accounts, but a Compute client is needed to
	// create one. If omitted, the `region` argument of the provider is used.
	// Changing this creates a new keypair.
	Region pulumi.StringPtrInput
	// Map of additional options.
	ValueSpecs pulumi.MapInput
}

func (KeypairState) ElementType 

func (KeypairState) ElementType() reflect.Type

type LookupAggregateV2Args added in v2.11.0 

type LookupAggregateV2Args struct {
	// List of Hypervisors contained in the Host Aggregate
	Hosts []string `pulumi:"hosts"`
	// Metadata of the Host Aggregate
	Metadata map[string]string `pulumi:"metadata"`
	// The name of the host aggregate
	Name string `pulumi:"name"`
}

A collection of arguments for invoking getAggregateV2.

type LookupAggregateV2Result added in v2.11.0 

type LookupAggregateV2Result struct {
	// List of Hypervisors contained in the Host Aggregate
	Hosts []string `pulumi:"hosts"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Metadata of the Host Aggregate
	Metadata map[string]string `pulumi:"metadata"`
	// See Argument Reference above.
	Name string `pulumi:"name"`
	// Availability zone of the Host Aggregate
	Zone string `pulumi:"zone"`
}

A collection of values returned by getAggregateV2.

func LookupAggregateV2 added in v2.11.0 

func LookupAggregateV2(ctx *pulumi.Context, args *LookupAggregateV2Args, opts ...pulumi.InvokeOption) (*LookupAggregateV2Result, error)

Use this data source to get information about host aggregates by name.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.LookupAggregateV2(ctx, &compute.LookupAggregateV2Args{
			Name: "test",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupFlavorArgs 

type LookupFlavorArgs struct {
	// The exact amount of disk (in gigabytes).
	Disk *int `pulumi:"disk"`
	// The ID of the flavor. Conflicts with the `name`,
	// `minRam` and `minDisk`
	FlavorId *string `pulumi:"flavorId"`
	// The flavor visibility.
	IsPublic *bool `pulumi:"isPublic"`
	// The minimum amount of disk (in gigabytes). Conflicts
	// with the `flavorId`.
	MinDisk *int `pulumi:"minDisk"`
	// The minimum amount of RAM (in megabytes). Conflicts
	// with the `flavorId`.
	MinRam *int `pulumi:"minRam"`
	// The name of the flavor. Conflicts with the `flavorId`.
	Name *string `pulumi:"name"`
	// The exact amount of RAM (in megabytes).
	Ram *int `pulumi:"ram"`
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used.
	Region *string `pulumi:"region"`
	// The `rxTxFactor` of the flavor.
	RxTxFactor *float64 `pulumi:"rxTxFactor"`
	// The amount of swap (in gigabytes).
	Swap *int `pulumi:"swap"`
	// The amount of VCPUs.
	Vcpus *int `pulumi:"vcpus"`
}

A collection of arguments for invoking getFlavor.

type LookupFlavorResult 

type LookupFlavorResult struct {
	Disk *int `pulumi:"disk"`
	// Key/Value pairs of metadata for the flavor.
	ExtraSpecs map[string]interface{} `pulumi:"extraSpecs"`
	FlavorId   *string                `pulumi:"flavorId"`
	// The provider-assigned unique ID for this managed resource.
	Id         string   `pulumi:"id"`
	IsPublic   *bool    `pulumi:"isPublic"`
	MinDisk    *int     `pulumi:"minDisk"`
	MinRam     *int     `pulumi:"minRam"`
	Name       *string  `pulumi:"name"`
	Ram        *int     `pulumi:"ram"`
	Region     string   `pulumi:"region"`
	RxTxFactor *float64 `pulumi:"rxTxFactor"`
	Swap       *int     `pulumi:"swap"`
	Vcpus      *int     `pulumi:"vcpus"`
}

A collection of values returned by getFlavor.

func LookupFlavor 

func LookupFlavor(ctx *pulumi.Context, args *LookupFlavorArgs, opts ...pulumi.InvokeOption) (*LookupFlavorResult, error)

Use this data source to get the ID of an available OpenStack flavor.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := 512
		opt1 := 1
		_, err := compute.LookupFlavor(ctx, &compute.LookupFlavorArgs{
			Ram:   &opt0,
			Vcpus: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupKeypairArgs 

type LookupKeypairArgs struct {
	// The unique name of the keypair.
	Name string `pulumi:"name"`
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used.
	Region *string `pulumi:"region"`
}

A collection of arguments for invoking getKeypair.

type LookupKeypairResult 

type LookupKeypairResult struct {
	// The fingerprint of the OpenSSH key.
	Fingerprint string `pulumi:"fingerprint"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// See Argument Reference above.
	Name string `pulumi:"name"`
	// The OpenSSH-formatted public key of the keypair.
	PublicKey string `pulumi:"publicKey"`
	// See Argument Reference above.
	Region string `pulumi:"region"`
}

A collection of values returned by getKeypair.

func LookupKeypair 

func LookupKeypair(ctx *pulumi.Context, args *LookupKeypairArgs, opts ...pulumi.InvokeOption) (*LookupKeypairResult, error)

Use this data source to get the ID and public key of an OpenStack keypair.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.LookupKeypair(ctx, &compute.LookupKeypairArgs{
			Name: "sand",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type QuotaSetV2 

type QuotaSetV2 struct {
	pulumi.CustomResourceState

	// Quota value for cores.
	// Changing this updates the existing quotaset.
	Cores pulumi.IntOutput `pulumi:"cores"`
	// Quota value for fixed IPs.
	// Changing this updates the existing quotaset.
	FixedIps pulumi.IntOutput `pulumi:"fixedIps"`
	// Quota value for floating IPs.
	// Changing this updates the existing quotaset.
	FloatingIps pulumi.IntOutput `pulumi:"floatingIps"`
	// Quota value for content bytes
	// of injected files. Changing this updates the existing quotaset.
	InjectedFileContentBytes pulumi.IntOutput `pulumi:"injectedFileContentBytes"`
	// Quota value for path bytes of
	// injected files. Changing this updates the existing quotaset.
	InjectedFilePathBytes pulumi.IntOutput `pulumi:"injectedFilePathBytes"`
	// Quota value for injected files.
	// Changing this updates the existing quotaset.
	InjectedFiles pulumi.IntOutput `pulumi:"injectedFiles"`
	// Quota value for instances.
	// Changing this updates the existing quotaset.
	Instances pulumi.IntOutput `pulumi:"instances"`
	// Quota value for key pairs.
	// Changing this updates the existing quotaset.
	KeyPairs pulumi.IntOutput `pulumi:"keyPairs"`
	// Quota value for metadata items.
	// Changing this updates the existing quotaset.
	MetadataItems pulumi.IntOutput `pulumi:"metadataItems"`
	// ID of the project to manage quotas.
	// Changing this creates a new quotaset.
	ProjectId pulumi.StringOutput `pulumi:"projectId"`
	// Quota value for RAM.
	// Changing this updates the existing quotaset.
	Ram pulumi.IntOutput `pulumi:"ram"`
	// The region in which to create the volume. If
	// omitted, the `region` argument of the provider is used. Changing this
	// creates a new quotaset.
	Region pulumi.StringOutput `pulumi:"region"`
	// Quota value for security group rules.
	// Changing this updates the existing quotaset.
	SecurityGroupRules pulumi.IntOutput `pulumi:"securityGroupRules"`
	// Quota value for security groups.
	// Changing this updates the existing quotaset.
	SecurityGroups pulumi.IntOutput `pulumi:"securityGroups"`
	// Quota value for server groups members.
	// Changing this updates the existing quotaset.
	ServerGroupMembers pulumi.IntOutput `pulumi:"serverGroupMembers"`
	// Quota value for server groups.
	// Changing this updates the existing quotaset.
	ServerGroups pulumi.IntOutput `pulumi:"serverGroups"`
}

Manages a V2 compute quotaset resource within OpenStack.

> **Note:** This usually requires admin privileges.

> **Note:** This resource has a no-op deletion so no actual actions will be done against the OpenStack API 

in case of delete call.

> **Note:** This resource has all-in creation so all optional quota arguments that were not specified are 

created with zero value.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/identity"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project1, err := identity.NewProject(ctx, "project1", nil)
		if err != nil {
			return err
		}
		_, err = compute.NewQuotaSetV2(ctx, "quotaset1", &compute.QuotaSetV2Args{
			ProjectId:          project1.ID(),
			KeyPairs:           pulumi.Int(10),
			Ram:                pulumi.Int(40960),
			Cores:              pulumi.Int(32),
			Instances:          pulumi.Int(20),
			ServerGroups:       pulumi.Int(4),
			ServerGroupMembers: pulumi.Int(8),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Quotasets can be imported using the `project_id/region_name`, e.g.

```sh 

$ pulumi import openstack:compute/quotaSetV2:QuotaSetV2 quotaset_1 2a0f2240-c5e6-41de-896d-e80d97428d6b/region_1

```

func GetQuotaSetV2 

func GetQuotaSetV2(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *QuotaSetV2State, opts ...pulumi.ResourceOption) (*QuotaSetV2, error)

GetQuotaSetV2 gets an existing QuotaSetV2 resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewQuotaSetV2 

func NewQuotaSetV2(ctx *pulumi.Context,
	name string, args *QuotaSetV2Args, opts ...pulumi.ResourceOption) (*QuotaSetV2, error)

NewQuotaSetV2 registers a new resource with the given unique name, arguments, and options.

func (*QuotaSetV2) ElementType added in v2.10.0 

func (*QuotaSetV2) ElementType() reflect.Type

func (*QuotaSetV2) ToQuotaSetV2Output added in v2.10.0 

func (i *QuotaSetV2) ToQuotaSetV2Output() QuotaSetV2Output

func (*QuotaSetV2) ToQuotaSetV2OutputWithContext added in v2.10.0 

func (i *QuotaSetV2) ToQuotaSetV2OutputWithContext(ctx context.Context) QuotaSetV2Output

func (*QuotaSetV2) ToQuotaSetV2PtrOutput added in v2.14.1 

func (i *QuotaSetV2) ToQuotaSetV2PtrOutput() QuotaSetV2PtrOutput

func (*QuotaSetV2) ToQuotaSetV2PtrOutputWithContext added in v2.14.1 

func (i *QuotaSetV2) ToQuotaSetV2PtrOutputWithContext(ctx context.Context) QuotaSetV2PtrOutput

type QuotaSetV2Args 

type QuotaSetV2Args struct {
	// Quota value for cores.
	// Changing this updates the existing quotaset.
	Cores pulumi.IntPtrInput
	// Quota value for fixed IPs.
	// Changing this updates the existing quotaset.
	FixedIps pulumi.IntPtrInput
	// Quota value for floating IPs.
	// Changing this updates the existing quotaset.
	FloatingIps pulumi.IntPtrInput
	// Quota value for content bytes
	// of injected files. Changing this updates the existing quotaset.
	InjectedFileContentBytes pulumi.IntPtrInput
	// Quota value for path bytes of
	// injected files. Changing this updates the existing quotaset.
	InjectedFilePathBytes pulumi.IntPtrInput
	// Quota value for injected files.
	// Changing this updates the existing quotaset.
	InjectedFiles pulumi.IntPtrInput
	// Quota value for instances.
	// Changing this updates the existing quotaset.
	Instances pulumi.IntPtrInput
	// Quota value for key pairs.
	// Changing this updates the existing quotaset.
	KeyPairs pulumi.IntPtrInput
	// Quota value for metadata items.
	// Changing this updates the existing quotaset.
	MetadataItems pulumi.IntPtrInput
	// ID of the project to manage quotas.
	// Changing this creates a new quotaset.
	ProjectId pulumi.StringInput
	// Quota value for RAM.
	// Changing this updates the existing quotaset.
	Ram pulumi.IntPtrInput
	// The region in which to create the volume. If
	// omitted, the `region` argument of the provider is used. Changing this
	// creates a new quotaset.
	Region pulumi.StringPtrInput
	// Quota value for security group rules.
	// Changing this updates the existing quotaset.
	SecurityGroupRules pulumi.IntPtrInput
	// Quota value for security groups.
	// Changing this updates the existing quotaset.
	SecurityGroups pulumi.IntPtrInput
	// Quota value for server groups members.
	// Changing this updates the existing quotaset.
	ServerGroupMembers pulumi.IntPtrInput
	// Quota value for server groups.
	// Changing this updates the existing quotaset.
	ServerGroups pulumi.IntPtrInput
}

The set of arguments for constructing a QuotaSetV2 resource.

func (QuotaSetV2Args) ElementType 

func (QuotaSetV2Args) ElementType() reflect.Type

type QuotaSetV2Array added in v2.14.1 

type QuotaSetV2Array []QuotaSetV2Input

func (QuotaSetV2Array) ElementType added in v2.14.1 

func (QuotaSetV2Array) ElementType() reflect.Type

func (QuotaSetV2Array) ToQuotaSetV2ArrayOutput added in v2.14.1 

func (i QuotaSetV2Array) ToQuotaSetV2ArrayOutput() QuotaSetV2ArrayOutput

func (QuotaSetV2Array) ToQuotaSetV2ArrayOutputWithContext added in v2.14.1 

func (i QuotaSetV2Array) ToQuotaSetV2ArrayOutputWithContext(ctx context.Context) QuotaSetV2ArrayOutput

type QuotaSetV2ArrayInput added in v2.14.1 

type QuotaSetV2ArrayInput interface {
	pulumi.Input

	ToQuotaSetV2ArrayOutput() QuotaSetV2ArrayOutput
	ToQuotaSetV2ArrayOutputWithContext(context.Context) QuotaSetV2ArrayOutput
}

QuotaSetV2ArrayInput is an input type that accepts QuotaSetV2Array and QuotaSetV2ArrayOutput values. You can construct a concrete instance of `QuotaSetV2ArrayInput` via: 

QuotaSetV2Array{ QuotaSetV2Args{...} }

type QuotaSetV2ArrayOutput added in v2.14.1 

type QuotaSetV2ArrayOutput struct{ *pulumi.OutputState }

func (QuotaSetV2ArrayOutput) ElementType added in v2.14.1 

func (QuotaSetV2ArrayOutput) ElementType() reflect.Type

func (QuotaSetV2ArrayOutput) Index added in v2.14.1 

func (o QuotaSetV2ArrayOutput) Index(i pulumi.IntInput) QuotaSetV2Output

func (QuotaSetV2ArrayOutput) ToQuotaSetV2ArrayOutput added in v2.14.1 

func (o QuotaSetV2ArrayOutput) ToQuotaSetV2ArrayOutput() QuotaSetV2ArrayOutput

func (QuotaSetV2ArrayOutput) ToQuotaSetV2ArrayOutputWithContext added in v2.14.1 

func (o QuotaSetV2ArrayOutput) ToQuotaSetV2ArrayOutputWithContext(ctx context.Context) QuotaSetV2ArrayOutput

type QuotaSetV2Input added in v2.10.0 

type QuotaSetV2Input interface {
	pulumi.Input

	ToQuotaSetV2Output() QuotaSetV2Output
	ToQuotaSetV2OutputWithContext(ctx context.Context) QuotaSetV2Output
}

type QuotaSetV2Map added in v2.14.1 

type QuotaSetV2Map map[string]QuotaSetV2Input

func (QuotaSetV2Map) ElementType added in v2.14.1 

func (QuotaSetV2Map) ElementType() reflect.Type

func (QuotaSetV2Map) ToQuotaSetV2MapOutput added in v2.14.1 

func (i QuotaSetV2Map) ToQuotaSetV2MapOutput() QuotaSetV2MapOutput

func (QuotaSetV2Map) ToQuotaSetV2MapOutputWithContext added in v2.14.1 

func (i QuotaSetV2Map) ToQuotaSetV2MapOutputWithContext(ctx context.Context) QuotaSetV2MapOutput

type QuotaSetV2MapInput added in v2.14.1 

type QuotaSetV2MapInput interface {
	pulumi.Input

	ToQuotaSetV2MapOutput() QuotaSetV2MapOutput
	ToQuotaSetV2MapOutputWithContext(context.Context) QuotaSetV2MapOutput
}

QuotaSetV2MapInput is an input type that accepts QuotaSetV2Map and QuotaSetV2MapOutput values. You can construct a concrete instance of `QuotaSetV2MapInput` via: 

QuotaSetV2Map{ "key": QuotaSetV2Args{...} }

type QuotaSetV2MapOutput added in v2.14.1 

type QuotaSetV2MapOutput struct{ *pulumi.OutputState }

func (QuotaSetV2MapOutput) ElementType added in v2.14.1 

func (QuotaSetV2MapOutput) ElementType() reflect.Type

func (QuotaSetV2MapOutput) MapIndex added in v2.14.1 

func (o QuotaSetV2MapOutput) MapIndex(k pulumi.StringInput) QuotaSetV2Output

func (QuotaSetV2MapOutput) ToQuotaSetV2MapOutput added in v2.14.1 

func (o QuotaSetV2MapOutput) ToQuotaSetV2MapOutput() QuotaSetV2MapOutput

func (QuotaSetV2MapOutput) ToQuotaSetV2MapOutputWithContext added in v2.14.1 

func (o QuotaSetV2MapOutput) ToQuotaSetV2MapOutputWithContext(ctx context.Context) QuotaSetV2MapOutput

type QuotaSetV2Output added in v2.10.0 

type QuotaSetV2Output struct {
	*pulumi.OutputState
}

func (QuotaSetV2Output) ElementType added in v2.10.0 

func (QuotaSetV2Output) ElementType() reflect.Type

func (QuotaSetV2Output) ToQuotaSetV2Output added in v2.10.0 

func (o QuotaSetV2Output) ToQuotaSetV2Output() QuotaSetV2Output

func (QuotaSetV2Output) ToQuotaSetV2OutputWithContext added in v2.10.0 

func (o QuotaSetV2Output) ToQuotaSetV2OutputWithContext(ctx context.Context) QuotaSetV2Output

func (QuotaSetV2Output) ToQuotaSetV2PtrOutput added in v2.14.1 

func (o QuotaSetV2Output) ToQuotaSetV2PtrOutput() QuotaSetV2PtrOutput

func (QuotaSetV2Output) ToQuotaSetV2PtrOutputWithContext added in v2.14.1 

func (o QuotaSetV2Output) ToQuotaSetV2PtrOutputWithContext(ctx context.Context) QuotaSetV2PtrOutput

type QuotaSetV2PtrInput added in v2.14.1 

type QuotaSetV2PtrInput interface {
	pulumi.Input

	ToQuotaSetV2PtrOutput() QuotaSetV2PtrOutput
	ToQuotaSetV2PtrOutputWithContext(ctx context.Context) QuotaSetV2PtrOutput
}

type QuotaSetV2PtrOutput added in v2.14.1 

type QuotaSetV2PtrOutput struct {
	*pulumi.OutputState
}

func (QuotaSetV2PtrOutput) ElementType added in v2.14.1 

func (QuotaSetV2PtrOutput) ElementType() reflect.Type

func (QuotaSetV2PtrOutput) ToQuotaSetV2PtrOutput added in v2.14.1 

func (o QuotaSetV2PtrOutput) ToQuotaSetV2PtrOutput() QuotaSetV2PtrOutput

func (QuotaSetV2PtrOutput) ToQuotaSetV2PtrOutputWithContext added in v2.14.1 

func (o QuotaSetV2PtrOutput) ToQuotaSetV2PtrOutputWithContext(ctx context.Context) QuotaSetV2PtrOutput

type QuotaSetV2State 

type QuotaSetV2State struct {
	// Quota value for cores.
	// Changing this updates the existing quotaset.
	Cores pulumi.IntPtrInput
	// Quota value for fixed IPs.
	// Changing this updates the existing quotaset.
	FixedIps pulumi.IntPtrInput
	// Quota value for floating IPs.
	// Changing this updates the existing quotaset.
	FloatingIps pulumi.IntPtrInput
	// Quota value for content bytes
	// of injected files. Changing this updates the existing quotaset.
	InjectedFileContentBytes pulumi.IntPtrInput
	// Quota value for path bytes of
	// injected files. Changing this updates the existing quotaset.
	InjectedFilePathBytes pulumi.IntPtrInput
	// Quota value for injected files.
	// Changing this updates the existing quotaset.
	InjectedFiles pulumi.IntPtrInput
	// Quota value for instances.
	// Changing this updates the existing quotaset.
	Instances pulumi.IntPtrInput
	// Quota value for key pairs.
	// Changing this updates the existing quotaset.
	KeyPairs pulumi.IntPtrInput
	// Quota value for metadata items.
	// Changing this updates the existing quotaset.
	MetadataItems pulumi.IntPtrInput
	// ID of the project to manage quotas.
	// Changing this creates a new quotaset.
	ProjectId pulumi.StringPtrInput
	// Quota value for RAM.
	// Changing this updates the existing quotaset.
	Ram pulumi.IntPtrInput
	// The region in which to create the volume. If
	// omitted, the `region` argument of the provider is used. Changing this
	// creates a new quotaset.
	Region pulumi.StringPtrInput
	// Quota value for security group rules.
	// Changing this updates the existing quotaset.
	SecurityGroupRules pulumi.IntPtrInput
	// Quota value for security groups.
	// Changing this updates the existing quotaset.
	SecurityGroups pulumi.IntPtrInput
	// Quota value for server groups members.
	// Changing this updates the existing quotaset.
	ServerGroupMembers pulumi.IntPtrInput
	// Quota value for server groups.
	// Changing this updates the existing quotaset.
	ServerGroups pulumi.IntPtrInput
}

func (QuotaSetV2State) ElementType 

func (QuotaSetV2State) ElementType() reflect.Type

type SecGroup 

type SecGroup struct {
	pulumi.CustomResourceState

	// A description for the security group. Changing this
	// updates the `description` of an existing security group.
	Description pulumi.StringOutput `pulumi:"description"`
	// A unique name for the security group. Changing this
	// updates the `name` of an existing security group.
	Name pulumi.StringOutput `pulumi:"name"`
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a security group. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// security group.
	Region pulumi.StringOutput `pulumi:"region"`
	// A rule describing how the security group operates. The
	// rule object structure is documented below. Changing this updates the
	// security group rules. As shown in the example above, multiple rule blocks
	// may be used.
	Rules SecGroupRuleArrayOutput `pulumi:"rules"`
}

Manages a V2 security group resource within OpenStack.

Please note that managing security groups through the OpenStack Compute API has been deprecated. Unless you are using an older OpenStack environment, it is recommended to use the `networking.SecGroup` and `networking.SecGroupRule` resources instead, which uses the OpenStack Networking API.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewSecGroup(ctx, "secgroup1", &compute.SecGroupArgs{
			Description: pulumi.String("my security group"),
			Rules: compute.SecGroupRuleArray{
				&compute.SecGroupRuleArgs{
					Cidr:       pulumi.String("0.0.0.0/0"),
					FromPort:   pulumi.Int(22),
					IpProtocol: pulumi.String("tcp"),
					ToPort:     pulumi.Int(22),
				},
				&compute.SecGroupRuleArgs{
					Cidr:       pulumi.String("0.0.0.0/0"),
					FromPort:   pulumi.Int(80),
					IpProtocol: pulumi.String("tcp"),
					ToPort:     pulumi.Int(80),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ## Notes

### ICMP Rules

When using ICMP as the `ipProtocol`, the `fromPort` sets the ICMP _type_ and the `toPort` sets the ICMP _code_. To allow all ICMP types, set each value to `-1`, like so:

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}

```

A list of ICMP types and codes can be found [here](https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages).

## Import

Security Groups can be imported using the `id`, e.g.

```sh 

$ pulumi import openstack:compute/secGroup:SecGroup my_secgroup 1bc30ee9-9d5b-4c30-bdd5-7f1e663f5edf

```

func GetSecGroup 

func GetSecGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SecGroupState, opts ...pulumi.ResourceOption) (*SecGroup, error)

GetSecGroup gets an existing SecGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSecGroup 

func NewSecGroup(ctx *pulumi.Context,
	name string, args *SecGroupArgs, opts ...pulumi.ResourceOption) (*SecGroup, error)

NewSecGroup registers a new resource with the given unique name, arguments, and options.

func (*SecGroup) ElementType added in v2.10.0 

func (*SecGroup) ElementType() reflect.Type

func (*SecGroup) ToSecGroupOutput added in v2.10.0 

func (i *SecGroup) ToSecGroupOutput() SecGroupOutput

func (*SecGroup) ToSecGroupOutputWithContext added in v2.10.0 

func (i *SecGroup) ToSecGroupOutputWithContext(ctx context.Context) SecGroupOutput

func (*SecGroup) ToSecGroupPtrOutput added in v2.14.1 

func (i *SecGroup) ToSecGroupPtrOutput() SecGroupPtrOutput

func (*SecGroup) ToSecGroupPtrOutputWithContext added in v2.14.1 

func (i *SecGroup) ToSecGroupPtrOutputWithContext(ctx context.Context) SecGroupPtrOutput

type SecGroupArgs 

type SecGroupArgs struct {
	// A description for the security group. Changing this
	// updates the `description` of an existing security group.
	Description pulumi.StringInput
	// A unique name for the security group. Changing this
	// updates the `name` of an existing security group.
	Name pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a security group. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// security group.
	Region pulumi.StringPtrInput
	// A rule describing how the security group operates. The
	// rule object structure is documented below. Changing this updates the
	// security group rules. As shown in the example above, multiple rule blocks
	// may be used.
	Rules SecGroupRuleArrayInput
}

The set of arguments for constructing a SecGroup resource.

func (SecGroupArgs) ElementType 

func (SecGroupArgs) ElementType() reflect.Type

type SecGroupArray added in v2.14.1 

type SecGroupArray []SecGroupInput

func (SecGroupArray) ElementType added in v2.14.1 

func (SecGroupArray) ElementType() reflect.Type

func (SecGroupArray) ToSecGroupArrayOutput added in v2.14.1 

func (i SecGroupArray) ToSecGroupArrayOutput() SecGroupArrayOutput

func (SecGroupArray) ToSecGroupArrayOutputWithContext added in v2.14.1 

func (i SecGroupArray) ToSecGroupArrayOutputWithContext(ctx context.Context) SecGroupArrayOutput

type SecGroupArrayInput added in v2.14.1 

type SecGroupArrayInput interface {
	pulumi.Input

	ToSecGroupArrayOutput() SecGroupArrayOutput
	ToSecGroupArrayOutputWithContext(context.Context) SecGroupArrayOutput
}

SecGroupArrayInput is an input type that accepts SecGroupArray and SecGroupArrayOutput values. You can construct a concrete instance of `SecGroupArrayInput` via: 

SecGroupArray{ SecGroupArgs{...} }

type SecGroupArrayOutput added in v2.14.1 

type SecGroupArrayOutput struct{ *pulumi.OutputState }

func (SecGroupArrayOutput) ElementType added in v2.14.1 

func (SecGroupArrayOutput) ElementType() reflect.Type

func (SecGroupArrayOutput) Index added in v2.14.1 

func (o SecGroupArrayOutput) Index(i pulumi.IntInput) SecGroupOutput

func (SecGroupArrayOutput) ToSecGroupArrayOutput added in v2.14.1 

func (o SecGroupArrayOutput) ToSecGroupArrayOutput() SecGroupArrayOutput

func (SecGroupArrayOutput) ToSecGroupArrayOutputWithContext added in v2.14.1 

func (o SecGroupArrayOutput) ToSecGroupArrayOutputWithContext(ctx context.Context) SecGroupArrayOutput

type SecGroupInput added in v2.10.0 

type SecGroupInput interface {
	pulumi.Input

	ToSecGroupOutput() SecGroupOutput
	ToSecGroupOutputWithContext(ctx context.Context) SecGroupOutput
}

type SecGroupMap added in v2.14.1 

type SecGroupMap map[string]SecGroupInput

func (SecGroupMap) ElementType added in v2.14.1 

func (SecGroupMap) ElementType() reflect.Type

func (SecGroupMap) ToSecGroupMapOutput added in v2.14.1 

func (i SecGroupMap) ToSecGroupMapOutput() SecGroupMapOutput

func (SecGroupMap) ToSecGroupMapOutputWithContext added in v2.14.1 

func (i SecGroupMap) ToSecGroupMapOutputWithContext(ctx context.Context) SecGroupMapOutput

type SecGroupMapInput added in v2.14.1 

type SecGroupMapInput interface {
	pulumi.Input

	ToSecGroupMapOutput() SecGroupMapOutput
	ToSecGroupMapOutputWithContext(context.Context) SecGroupMapOutput
}

SecGroupMapInput is an input type that accepts SecGroupMap and SecGroupMapOutput values. You can construct a concrete instance of `SecGroupMapInput` via: 

SecGroupMap{ "key": SecGroupArgs{...} }

type SecGroupMapOutput added in v2.14.1 

type SecGroupMapOutput struct{ *pulumi.OutputState }

func (SecGroupMapOutput) ElementType added in v2.14.1 

func (SecGroupMapOutput) ElementType() reflect.Type

func (SecGroupMapOutput) MapIndex added in v2.14.1 

func (o SecGroupMapOutput) MapIndex(k pulumi.StringInput) SecGroupOutput

func (SecGroupMapOutput) ToSecGroupMapOutput added in v2.14.1 

func (o SecGroupMapOutput) ToSecGroupMapOutput() SecGroupMapOutput

func (SecGroupMapOutput) ToSecGroupMapOutputWithContext added in v2.14.1 

func (o SecGroupMapOutput) ToSecGroupMapOutputWithContext(ctx context.Context) SecGroupMapOutput

type SecGroupOutput added in v2.10.0 

type SecGroupOutput struct {
	*pulumi.OutputState
}

func (SecGroupOutput) ElementType added in v2.10.0 

func (SecGroupOutput) ElementType() reflect.Type

func (SecGroupOutput) ToSecGroupOutput added in v2.10.0 

func (o SecGroupOutput) ToSecGroupOutput() SecGroupOutput

func (SecGroupOutput) ToSecGroupOutputWithContext added in v2.10.0 

func (o SecGroupOutput) ToSecGroupOutputWithContext(ctx context.Context) SecGroupOutput

func (SecGroupOutput) ToSecGroupPtrOutput added in v2.14.1 

func (o SecGroupOutput) ToSecGroupPtrOutput() SecGroupPtrOutput

func (SecGroupOutput) ToSecGroupPtrOutputWithContext added in v2.14.1 

func (o SecGroupOutput) ToSecGroupPtrOutputWithContext(ctx context.Context) SecGroupPtrOutput

type SecGroupPtrInput added in v2.14.1 

type SecGroupPtrInput interface {
	pulumi.Input

	ToSecGroupPtrOutput() SecGroupPtrOutput
	ToSecGroupPtrOutputWithContext(ctx context.Context) SecGroupPtrOutput
}

type SecGroupPtrOutput added in v2.14.1 

type SecGroupPtrOutput struct {
	*pulumi.OutputState
}

func (SecGroupPtrOutput) ElementType added in v2.14.1 

func (SecGroupPtrOutput) ElementType() reflect.Type

func (SecGroupPtrOutput) ToSecGroupPtrOutput added in v2.14.1 

func (o SecGroupPtrOutput) ToSecGroupPtrOutput() SecGroupPtrOutput

func (SecGroupPtrOutput) ToSecGroupPtrOutputWithContext added in v2.14.1 

func (o SecGroupPtrOutput) ToSecGroupPtrOutputWithContext(ctx context.Context) SecGroupPtrOutput

type SecGroupRule 

type SecGroupRule struct {
	// Required if `fromGroupId` or `self` is empty. The IP range
	// that will be the source of network traffic to the security group. Use 0.0.0.0/0
	// to allow all IP addresses. Changing this creates a new security group rule. Cannot
	// be combined with `fromGroupId` or `self`.
	Cidr *string `pulumi:"cidr"`
	// Required if `cidr` or `self` is empty. The ID of a
	// group from which to forward traffic to the parent group. Changing this creates a
	// new security group rule. Cannot be combined with `cidr` or `self`.
	FromGroupId *string `pulumi:"fromGroupId"`
	// An integer representing the lower bound of the port
	// range to open. Changing this creates a new security group rule.
	FromPort int     `pulumi:"fromPort"`
	Id       *string `pulumi:"id"`
	// The protocol type that will be allowed. Changing
	// this creates a new security group rule.
	IpProtocol string `pulumi:"ipProtocol"`
	// Required if `cidr` and `fromGroupId` is empty. If true,
	// the security group itself will be added as a source to this ingress rule. Cannot
	// be combined with `cidr` or `fromGroupId`.
	Self *bool `pulumi:"self"`
	// An integer representing the upper bound of the port
	// range to open. Changing this creates a new security group rule.
	ToPort int `pulumi:"toPort"`
}

type SecGroupRuleArgs 

type SecGroupRuleArgs struct {
	// Required if `fromGroupId` or `self` is empty. The IP range
	// that will be the source of network traffic to the security group. Use 0.0.0.0/0
	// to allow all IP addresses. Changing this creates a new security group rule. Cannot
	// be combined with `fromGroupId` or `self`.
	Cidr pulumi.StringPtrInput `pulumi:"cidr"`
	// Required if `cidr` or `self` is empty. The ID of a
	// group from which to forward traffic to the parent group. Changing this creates a
	// new security group rule. Cannot be combined with `cidr` or `self`.
	FromGroupId pulumi.StringPtrInput `pulumi:"fromGroupId"`
	// An integer representing the lower bound of the port
	// range to open. Changing this creates a new security group rule.
	FromPort pulumi.IntInput       `pulumi:"fromPort"`
	Id       pulumi.StringPtrInput `pulumi:"id"`
	// The protocol type that will be allowed. Changing
	// this creates a new security group rule.
	IpProtocol pulumi.StringInput `pulumi:"ipProtocol"`
	// Required if `cidr` and `fromGroupId` is empty. If true,
	// the security group itself will be added as a source to this ingress rule. Cannot
	// be combined with `cidr` or `fromGroupId`.
	Self pulumi.BoolPtrInput `pulumi:"self"`
	// An integer representing the upper bound of the port
	// range to open. Changing this creates a new security group rule.
	ToPort pulumi.IntInput `pulumi:"toPort"`
}

func (SecGroupRuleArgs) ElementType 

func (SecGroupRuleArgs) ElementType() reflect.Type

func (SecGroupRuleArgs) ToSecGroupRuleOutput 

func (i SecGroupRuleArgs) ToSecGroupRuleOutput() SecGroupRuleOutput

func (SecGroupRuleArgs) ToSecGroupRuleOutputWithContext 

func (i SecGroupRuleArgs) ToSecGroupRuleOutputWithContext(ctx context.Context) SecGroupRuleOutput

type SecGroupRuleArray 

type SecGroupRuleArray []SecGroupRuleInput

func (SecGroupRuleArray) ElementType 

func (SecGroupRuleArray) ElementType() reflect.Type

func (SecGroupRuleArray) ToSecGroupRuleArrayOutput 

func (i SecGroupRuleArray) ToSecGroupRuleArrayOutput() SecGroupRuleArrayOutput

func (SecGroupRuleArray) ToSecGroupRuleArrayOutputWithContext 

func (i SecGroupRuleArray) ToSecGroupRuleArrayOutputWithContext(ctx context.Context) SecGroupRuleArrayOutput

type SecGroupRuleArrayInput 

type SecGroupRuleArrayInput interface {
	pulumi.Input

	ToSecGroupRuleArrayOutput() SecGroupRuleArrayOutput
	ToSecGroupRuleArrayOutputWithContext(context.Context) SecGroupRuleArrayOutput
}

SecGroupRuleArrayInput is an input type that accepts SecGroupRuleArray and SecGroupRuleArrayOutput values. You can construct a concrete instance of `SecGroupRuleArrayInput` via: 

SecGroupRuleArray{ SecGroupRuleArgs{...} }

type SecGroupRuleArrayOutput 

type SecGroupRuleArrayOutput struct{ *pulumi.OutputState }

func (SecGroupRuleArrayOutput) ElementType 

func (SecGroupRuleArrayOutput) ElementType() reflect.Type

func (SecGroupRuleArrayOutput) Index 

func (o SecGroupRuleArrayOutput) Index(i pulumi.IntInput) SecGroupRuleOutput

func (SecGroupRuleArrayOutput) ToSecGroupRuleArrayOutput 

func (o SecGroupRuleArrayOutput) ToSecGroupRuleArrayOutput() SecGroupRuleArrayOutput

func (SecGroupRuleArrayOutput) ToSecGroupRuleArrayOutputWithContext 

func (o SecGroupRuleArrayOutput) ToSecGroupRuleArrayOutputWithContext(ctx context.Context) SecGroupRuleArrayOutput

type SecGroupRuleInput 

type SecGroupRuleInput interface {
	pulumi.Input

	ToSecGroupRuleOutput() SecGroupRuleOutput
	ToSecGroupRuleOutputWithContext(context.Context) SecGroupRuleOutput
}

SecGroupRuleInput is an input type that accepts SecGroupRuleArgs and SecGroupRuleOutput values. You can construct a concrete instance of `SecGroupRuleInput` via: 

SecGroupRuleArgs{...}

type SecGroupRuleOutput 

type SecGroupRuleOutput struct{ *pulumi.OutputState }

func (SecGroupRuleOutput) Cidr 

func (o SecGroupRuleOutput) Cidr() pulumi.StringPtrOutput

Required if `fromGroupId` or `self` is empty. The IP range that will be the source of network traffic to the security group. Use 0.0.0.0/0 to allow all IP addresses. Changing this creates a new security group rule. Cannot be combined with `fromGroupId` or `self`.

func (SecGroupRuleOutput) ElementType 

func (SecGroupRuleOutput) ElementType() reflect.Type

func (SecGroupRuleOutput) FromGroupId 

func (o SecGroupRuleOutput) FromGroupId() pulumi.StringPtrOutput

Required if `cidr` or `self` is empty. The ID of a group from which to forward traffic to the parent group. Changing this creates a new security group rule. Cannot be combined with `cidr` or `self`.

func (SecGroupRuleOutput) FromPort 

func (o SecGroupRuleOutput) FromPort() pulumi.IntOutput

An integer representing the lower bound of the port range to open. Changing this creates a new security group rule.

func (SecGroupRuleOutput) Id 

func (o SecGroupRuleOutput) Id() pulumi.StringPtrOutput

func (SecGroupRuleOutput) IpProtocol 

func (o SecGroupRuleOutput) IpProtocol() pulumi.StringOutput

The protocol type that will be allowed. Changing this creates a new security group rule.

func (SecGroupRuleOutput) Self 

func (o SecGroupRuleOutput) Self() pulumi.BoolPtrOutput

Required if `cidr` and `fromGroupId` is empty. If true, the security group itself will be added as a source to this ingress rule. Cannot be combined with `cidr` or `fromGroupId`.

func (SecGroupRuleOutput) ToPort 

func (o SecGroupRuleOutput) ToPort() pulumi.IntOutput

An integer representing the upper bound of the port range to open. Changing this creates a new security group rule.

func (SecGroupRuleOutput) ToSecGroupRuleOutput 

func (o SecGroupRuleOutput) ToSecGroupRuleOutput() SecGroupRuleOutput

func (SecGroupRuleOutput) ToSecGroupRuleOutputWithContext 

func (o SecGroupRuleOutput) ToSecGroupRuleOutputWithContext(ctx context.Context) SecGroupRuleOutput

type SecGroupState 

type SecGroupState struct {
	// A description for the security group. Changing this
	// updates the `description` of an existing security group.
	Description pulumi.StringPtrInput
	// A unique name for the security group. Changing this
	// updates the `name` of an existing security group.
	Name pulumi.StringPtrInput
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a security group. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// security group.
	Region pulumi.StringPtrInput
	// A rule describing how the security group operates. The
	// rule object structure is documented below. Changing this updates the
	// security group rules. As shown in the example above, multiple rule blocks
	// may be used.
	Rules SecGroupRuleArrayInput
}

func (SecGroupState) ElementType 

func (SecGroupState) ElementType() reflect.Type

type ServerGroup 

type ServerGroup struct {
	pulumi.CustomResourceState

	// The instances that are part of this server group.
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// A unique name for the server group. Changing this creates
	// a new server group.
	Name pulumi.StringOutput `pulumi:"name"`
	// The set of policies for the server group. All policies
	// are mutually exclusive. See the Policies section for more information.
	// Changing this creates a new server group.
	Policies pulumi.StringArrayOutput `pulumi:"policies"`
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used. Changing
	// this creates a new server group.
	Region pulumi.StringOutput `pulumi:"region"`
	// Map of additional options.
	ValueSpecs pulumi.MapOutput `pulumi:"valueSpecs"`
}

Manages a V2 Server Group resource within OpenStack.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewServerGroup(ctx, "test_sg", &compute.ServerGroupArgs{
			Policies: pulumi.StringArray{
				pulumi.String("anti-affinity"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ## Policies

  • `affinity` - All instances/servers launched in this group will be hosted on the same compute node.
  • `anti-affinity` - All instances/servers launched in this group will be hosted on different compute nodes.
  • `soft-affinity` - All instances/servers launched in this group will be hosted on the same compute node if possible, but if not possible they still will be scheduled instead of failure. To use this policy your OpenStack environment should support Compute service API 2.15 or above.
  • `soft-anti-affinity` - All instances/servers launched in this group will be hosted on different compute nodes if possible, but if not possible they still will be scheduled instead of failure. To use this policy your OpenStack environment should support Compute service API 2.15 or above.

## Import

Server Groups can be imported using the `id`, e.g.

```sh 

$ pulumi import openstack:compute/serverGroup:ServerGroup test-sg 1bc30ee9-9d5b-4c30-bdd5-7f1e663f5edf

```

func GetServerGroup 

func GetServerGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServerGroupState, opts ...pulumi.ResourceOption) (*ServerGroup, error)

GetServerGroup gets an existing ServerGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewServerGroup 

func NewServerGroup(ctx *pulumi.Context,
	name string, args *ServerGroupArgs, opts ...pulumi.ResourceOption) (*ServerGroup, error)

NewServerGroup registers a new resource with the given unique name, arguments, and options.

func (*ServerGroup) ElementType added in v2.10.0 

func (*ServerGroup) ElementType() reflect.Type

func (*ServerGroup) ToServerGroupOutput added in v2.10.0 

func (i *ServerGroup) ToServerGroupOutput() ServerGroupOutput

func (*ServerGroup) ToServerGroupOutputWithContext added in v2.10.0 

func (i *ServerGroup) ToServerGroupOutputWithContext(ctx context.Context) ServerGroupOutput

func (*ServerGroup) ToServerGroupPtrOutput added in v2.14.1 

func (i *ServerGroup) ToServerGroupPtrOutput() ServerGroupPtrOutput

func (*ServerGroup) ToServerGroupPtrOutputWithContext added in v2.14.1 

func (i *ServerGroup) ToServerGroupPtrOutputWithContext(ctx context.Context) ServerGroupPtrOutput

type ServerGroupArgs 

type ServerGroupArgs struct {
	// A unique name for the server group. Changing this creates
	// a new server group.
	Name pulumi.StringPtrInput
	// The set of policies for the server group. All policies
	// are mutually exclusive. See the Policies section for more information.
	// Changing this creates a new server group.
	Policies pulumi.StringArrayInput
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used. Changing
	// this creates a new server group.
	Region pulumi.StringPtrInput
	// Map of additional options.
	ValueSpecs pulumi.MapInput
}

The set of arguments for constructing a ServerGroup resource.

func (ServerGroupArgs) ElementType 

func (ServerGroupArgs) ElementType() reflect.Type

type ServerGroupArray added in v2.14.1 

type ServerGroupArray []ServerGroupInput

func (ServerGroupArray) ElementType added in v2.14.1 

func (ServerGroupArray) ElementType() reflect.Type

func (ServerGroupArray) ToServerGroupArrayOutput added in v2.14.1 

func (i ServerGroupArray) ToServerGroupArrayOutput() ServerGroupArrayOutput

func (ServerGroupArray) ToServerGroupArrayOutputWithContext added in v2.14.1 

func (i ServerGroupArray) ToServerGroupArrayOutputWithContext(ctx context.Context) ServerGroupArrayOutput

type ServerGroupArrayInput added in v2.14.1 

type ServerGroupArrayInput interface {
	pulumi.Input

	ToServerGroupArrayOutput() ServerGroupArrayOutput
	ToServerGroupArrayOutputWithContext(context.Context) ServerGroupArrayOutput
}

ServerGroupArrayInput is an input type that accepts ServerGroupArray and ServerGroupArrayOutput values. You can construct a concrete instance of `ServerGroupArrayInput` via: 

ServerGroupArray{ ServerGroupArgs{...} }

type ServerGroupArrayOutput added in v2.14.1 

type ServerGroupArrayOutput struct{ *pulumi.OutputState }

func (ServerGroupArrayOutput) ElementType added in v2.14.1 

func (ServerGroupArrayOutput) ElementType() reflect.Type

func (ServerGroupArrayOutput) Index added in v2.14.1 

func (o ServerGroupArrayOutput) Index(i pulumi.IntInput) ServerGroupOutput

func (ServerGroupArrayOutput) ToServerGroupArrayOutput added in v2.14.1 

func (o ServerGroupArrayOutput) ToServerGroupArrayOutput() ServerGroupArrayOutput

func (ServerGroupArrayOutput) ToServerGroupArrayOutputWithContext added in v2.14.1 

func (o ServerGroupArrayOutput) ToServerGroupArrayOutputWithContext(ctx context.Context) ServerGroupArrayOutput

type ServerGroupInput added in v2.10.0 

type ServerGroupInput interface {
	pulumi.Input

	ToServerGroupOutput() ServerGroupOutput
	ToServerGroupOutputWithContext(ctx context.Context) ServerGroupOutput
}

type ServerGroupMap added in v2.14.1 

type ServerGroupMap map[string]ServerGroupInput

func (ServerGroupMap) ElementType added in v2.14.1 

func (ServerGroupMap) ElementType() reflect.Type

func (ServerGroupMap) ToServerGroupMapOutput added in v2.14.1 

func (i ServerGroupMap) ToServerGroupMapOutput() ServerGroupMapOutput

func (ServerGroupMap) ToServerGroupMapOutputWithContext added in v2.14.1 

func (i ServerGroupMap) ToServerGroupMapOutputWithContext(ctx context.Context) ServerGroupMapOutput

type ServerGroupMapInput added in v2.14.1 

type ServerGroupMapInput interface {
	pulumi.Input

	ToServerGroupMapOutput() ServerGroupMapOutput
	ToServerGroupMapOutputWithContext(context.Context) ServerGroupMapOutput
}

ServerGroupMapInput is an input type that accepts ServerGroupMap and ServerGroupMapOutput values. You can construct a concrete instance of `ServerGroupMapInput` via: 

ServerGroupMap{ "key": ServerGroupArgs{...} }

type ServerGroupMapOutput added in v2.14.1 

type ServerGroupMapOutput struct{ *pulumi.OutputState }

func (ServerGroupMapOutput) ElementType added in v2.14.1 

func (ServerGroupMapOutput) ElementType() reflect.Type

func (ServerGroupMapOutput) MapIndex added in v2.14.1 

func (o ServerGroupMapOutput) MapIndex(k pulumi.StringInput) ServerGroupOutput

func (ServerGroupMapOutput) ToServerGroupMapOutput added in v2.14.1 

func (o ServerGroupMapOutput) ToServerGroupMapOutput() ServerGroupMapOutput

func (ServerGroupMapOutput) ToServerGroupMapOutputWithContext added in v2.14.1 

func (o ServerGroupMapOutput) ToServerGroupMapOutputWithContext(ctx context.Context) ServerGroupMapOutput

type ServerGroupOutput added in v2.10.0 

type ServerGroupOutput struct {
	*pulumi.OutputState
}

func (ServerGroupOutput) ElementType added in v2.10.0 

func (ServerGroupOutput) ElementType() reflect.Type

func (ServerGroupOutput) ToServerGroupOutput added in v2.10.0 

func (o ServerGroupOutput) ToServerGroupOutput() ServerGroupOutput

func (ServerGroupOutput) ToServerGroupOutputWithContext added in v2.10.0 

func (o ServerGroupOutput) ToServerGroupOutputWithContext(ctx context.Context) ServerGroupOutput

func (ServerGroupOutput) ToServerGroupPtrOutput added in v2.14.1 

func (o ServerGroupOutput) ToServerGroupPtrOutput() ServerGroupPtrOutput

func (ServerGroupOutput) ToServerGroupPtrOutputWithContext added in v2.14.1 

func (o ServerGroupOutput) ToServerGroupPtrOutputWithContext(ctx context.Context) ServerGroupPtrOutput

type ServerGroupPtrInput added in v2.14.1 

type ServerGroupPtrInput interface {
	pulumi.Input

	ToServerGroupPtrOutput() ServerGroupPtrOutput
	ToServerGroupPtrOutputWithContext(ctx context.Context) ServerGroupPtrOutput
}

type ServerGroupPtrOutput added in v2.14.1 

type ServerGroupPtrOutput struct {
	*pulumi.OutputState
}

func (ServerGroupPtrOutput) ElementType added in v2.14.1 

func (ServerGroupPtrOutput) ElementType() reflect.Type

func (ServerGroupPtrOutput) ToServerGroupPtrOutput added in v2.14.1 

func (o ServerGroupPtrOutput) ToServerGroupPtrOutput() ServerGroupPtrOutput

func (ServerGroupPtrOutput) ToServerGroupPtrOutputWithContext added in v2.14.1 

func (o ServerGroupPtrOutput) ToServerGroupPtrOutputWithContext(ctx context.Context) ServerGroupPtrOutput

type ServerGroupState 

type ServerGroupState struct {
	// The instances that are part of this server group.
	Members pulumi.StringArrayInput
	// A unique name for the server group. Changing this creates
	// a new server group.
	Name pulumi.StringPtrInput
	// The set of policies for the server group. All policies
	// are mutually exclusive. See the Policies section for more information.
	// Changing this creates a new server group.
	Policies pulumi.StringArrayInput
	// The region in which to obtain the V2 Compute client.
	// If omitted, the `region` argument of the provider is used. Changing
	// this creates a new server group.
	Region pulumi.StringPtrInput
	// Map of additional options.
	ValueSpecs pulumi.MapInput
}

func (ServerGroupState) ElementType 

func (ServerGroupState) ElementType() reflect.Type

type VolumeAttach 

type VolumeAttach struct {
	pulumi.CustomResourceState

	// See Argument Reference above. _NOTE_: The correctness of this
	// information is dependent upon the hypervisor in use. In some cases, this
	// should not be used as an authoritative piece of information.
	Device pulumi.StringOutput `pulumi:"device"`
	// The ID of the Instance to attach the Volume to.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
	// Enable attachment of multiattach-capable volumes.
	Multiattach pulumi.BoolPtrOutput `pulumi:"multiattach"`
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a volume attachment. If omitted, the
	// `region` argument of the provider is used. Changing this creates a
	// new volume attachment.
	Region pulumi.StringOutput `pulumi:"region"`
	// Map of additional vendor-specific options.
	// Supported options are described below.
	VendorOptions VolumeAttachVendorOptionsPtrOutput `pulumi:"vendorOptions"`
	// The ID of the Volume to attach to an Instance.
	VolumeId pulumi.StringOutput `pulumi:"volumeId"`
}

Attaches a Block Storage Volume to an Instance using the OpenStack Compute (Nova) v2 API.

## Example Usage ### Basic attachment of a single volume to a single instance

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/blockstorage"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		volume1, err := blockstorage.NewVolumeV2(ctx, "volume1", &blockstorage.VolumeV2Args{
			Size: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewVolumeAttach(ctx, "va1", &compute.VolumeAttachArgs{
			InstanceId: instance1.ID(),
			VolumeId:   volume1.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Using Multiattach-enabled volumes

Multiattach Volumes are dependent upon your OpenStack cloud and not all clouds support multiattach.

```go package main

import ( 

"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/blockstorage"
"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := blockstorage.NewVolume(ctx, "volume1", &blockstorage.VolumeArgs{
			Multiattach: pulumi.Bool(true),
			Size:        pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		instance2, err := compute.NewInstance(ctx, "instance2", &compute.InstanceArgs{
			SecurityGroups: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewVolumeAttach(ctx, "va1", &compute.VolumeAttachArgs{
			InstanceId:  instance1.ID(),
			Multiattach: pulumi.Bool(true),
			VolumeId:    pulumi.Any(openstack_blockstorage_volume_v2.Volume_1.Id),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewVolumeAttach(ctx, "va2", &compute.VolumeAttachArgs{
			InstanceId:  instance2.ID(),
			Multiattach: pulumi.Bool(true),
			VolumeId:    pulumi.Any(openstack_blockstorage_volume_v2.Volume_1.Id),
		}, pulumi.DependsOn([]pulumi.Resource{
			"openstack_compute_volume_attach_v2.va_1",
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

It is recommended to use `dependsOn` for the attach resources to enforce the volume attachments to happen one at a time.

## Import

Volume Attachments can be imported using the Instance ID and Volume ID separated by a slash, e.g.

```sh 

$ pulumi import openstack:compute/volumeAttach:VolumeAttach va_1 89c60255-9bd6-460c-822a-e2b959ede9d2/45670584-225f-46c3-b33e-6707b589b666

```

func GetVolumeAttach 

func GetVolumeAttach(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VolumeAttachState, opts ...pulumi.ResourceOption) (*VolumeAttach, error)

GetVolumeAttach gets an existing VolumeAttach resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVolumeAttach 

func NewVolumeAttach(ctx *pulumi.Context,
	name string, args *VolumeAttachArgs, opts ...pulumi.ResourceOption) (*VolumeAttach, error)

NewVolumeAttach registers a new resource with the given unique name, arguments, and options.

func (*VolumeAttach) ElementType added in v2.10.0 

func (*VolumeAttach) ElementType() reflect.Type

func (*VolumeAttach) ToVolumeAttachOutput added in v2.10.0 

func (i *VolumeAttach) ToVolumeAttachOutput() VolumeAttachOutput

func (*VolumeAttach) ToVolumeAttachOutputWithContext added in v2.10.0 

func (i *VolumeAttach) ToVolumeAttachOutputWithContext(ctx context.Context) VolumeAttachOutput

func (*VolumeAttach) ToVolumeAttachPtrOutput added in v2.14.1 

func (i *VolumeAttach) ToVolumeAttachPtrOutput() VolumeAttachPtrOutput

func (*VolumeAttach) ToVolumeAttachPtrOutputWithContext added in v2.14.1 

func (i *VolumeAttach) ToVolumeAttachPtrOutputWithContext(ctx context.Context) VolumeAttachPtrOutput

type VolumeAttachArgs 

type VolumeAttachArgs struct {
	// See Argument Reference above. _NOTE_: The correctness of this
	// information is dependent upon the hypervisor in use. In some cases, this
	// should not be used as an authoritative piece of information.
	Device pulumi.StringPtrInput
	// The ID of the Instance to attach the Volume to.
	InstanceId pulumi.StringInput
	// Enable attachment of multiattach-capable volumes.
	Multiattach pulumi.BoolPtrInput
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a volume attachment. If omitted, the
	// `region` argument of the provider is used. Changing this creates a
	// new volume attachment.
	Region pulumi.StringPtrInput
	// Map of additional vendor-specific options.
	// Supported options are described below.
	VendorOptions VolumeAttachVendorOptionsPtrInput
	// The ID of the Volume to attach to an Instance.
	VolumeId pulumi.StringInput
}

The set of arguments for constructing a VolumeAttach resource.

func (VolumeAttachArgs) ElementType 

func (VolumeAttachArgs) ElementType() reflect.Type

type VolumeAttachArray added in v2.14.1 

type VolumeAttachArray []VolumeAttachInput

func (VolumeAttachArray) ElementType added in v2.14.1 

func (VolumeAttachArray) ElementType() reflect.Type

func (VolumeAttachArray) ToVolumeAttachArrayOutput added in v2.14.1 

func (i VolumeAttachArray) ToVolumeAttachArrayOutput() VolumeAttachArrayOutput

func (VolumeAttachArray) ToVolumeAttachArrayOutputWithContext added in v2.14.1 

func (i VolumeAttachArray) ToVolumeAttachArrayOutputWithContext(ctx context.Context) VolumeAttachArrayOutput

type VolumeAttachArrayInput added in v2.14.1 

type VolumeAttachArrayInput interface {
	pulumi.Input

	ToVolumeAttachArrayOutput() VolumeAttachArrayOutput
	ToVolumeAttachArrayOutputWithContext(context.Context) VolumeAttachArrayOutput
}

VolumeAttachArrayInput is an input type that accepts VolumeAttachArray and VolumeAttachArrayOutput values. You can construct a concrete instance of `VolumeAttachArrayInput` via: 

VolumeAttachArray{ VolumeAttachArgs{...} }

type VolumeAttachArrayOutput added in v2.14.1 

type VolumeAttachArrayOutput struct{ *pulumi.OutputState }

func (VolumeAttachArrayOutput) ElementType added in v2.14.1 

func (VolumeAttachArrayOutput) ElementType() reflect.Type

func (VolumeAttachArrayOutput) Index added in v2.14.1 

func (o VolumeAttachArrayOutput) Index(i pulumi.IntInput) VolumeAttachOutput

func (VolumeAttachArrayOutput) ToVolumeAttachArrayOutput added in v2.14.1 

func (o VolumeAttachArrayOutput) ToVolumeAttachArrayOutput() VolumeAttachArrayOutput

func (VolumeAttachArrayOutput) ToVolumeAttachArrayOutputWithContext added in v2.14.1 

func (o VolumeAttachArrayOutput) ToVolumeAttachArrayOutputWithContext(ctx context.Context) VolumeAttachArrayOutput

type VolumeAttachInput added in v2.10.0 

type VolumeAttachInput interface {
	pulumi.Input

	ToVolumeAttachOutput() VolumeAttachOutput
	ToVolumeAttachOutputWithContext(ctx context.Context) VolumeAttachOutput
}

type VolumeAttachMap added in v2.14.1 

type VolumeAttachMap map[string]VolumeAttachInput

func (VolumeAttachMap) ElementType added in v2.14.1 

func (VolumeAttachMap) ElementType() reflect.Type

func (VolumeAttachMap) ToVolumeAttachMapOutput added in v2.14.1 

func (i VolumeAttachMap) ToVolumeAttachMapOutput() VolumeAttachMapOutput

func (VolumeAttachMap) ToVolumeAttachMapOutputWithContext added in v2.14.1 

func (i VolumeAttachMap) ToVolumeAttachMapOutputWithContext(ctx context.Context) VolumeAttachMapOutput

type VolumeAttachMapInput added in v2.14.1 

type VolumeAttachMapInput interface {
	pulumi.Input

	ToVolumeAttachMapOutput() VolumeAttachMapOutput
	ToVolumeAttachMapOutputWithContext(context.Context) VolumeAttachMapOutput
}

VolumeAttachMapInput is an input type that accepts VolumeAttachMap and VolumeAttachMapOutput values. You can construct a concrete instance of `VolumeAttachMapInput` via: 

VolumeAttachMap{ "key": VolumeAttachArgs{...} }

type VolumeAttachMapOutput added in v2.14.1 

type VolumeAttachMapOutput struct{ *pulumi.OutputState }

func (VolumeAttachMapOutput) ElementType added in v2.14.1 

func (VolumeAttachMapOutput) ElementType() reflect.Type

func (VolumeAttachMapOutput) MapIndex added in v2.14.1 

func (o VolumeAttachMapOutput) MapIndex(k pulumi.StringInput) VolumeAttachOutput

func (VolumeAttachMapOutput) ToVolumeAttachMapOutput added in v2.14.1 

func (o VolumeAttachMapOutput) ToVolumeAttachMapOutput() VolumeAttachMapOutput

func (VolumeAttachMapOutput) ToVolumeAttachMapOutputWithContext added in v2.14.1 

func (o VolumeAttachMapOutput) ToVolumeAttachMapOutputWithContext(ctx context.Context) VolumeAttachMapOutput

type VolumeAttachOutput added in v2.10.0 

type VolumeAttachOutput struct {
	*pulumi.OutputState
}

func (VolumeAttachOutput) ElementType added in v2.10.0 

func (VolumeAttachOutput) ElementType() reflect.Type

func (VolumeAttachOutput) ToVolumeAttachOutput added in v2.10.0 

func (o VolumeAttachOutput) ToVolumeAttachOutput() VolumeAttachOutput

func (VolumeAttachOutput) ToVolumeAttachOutputWithContext added in v2.10.0 

func (o VolumeAttachOutput) ToVolumeAttachOutputWithContext(ctx context.Context) VolumeAttachOutput

func (VolumeAttachOutput) ToVolumeAttachPtrOutput added in v2.14.1 

func (o VolumeAttachOutput) ToVolumeAttachPtrOutput() VolumeAttachPtrOutput

func (VolumeAttachOutput) ToVolumeAttachPtrOutputWithContext added in v2.14.1 

func (o VolumeAttachOutput) ToVolumeAttachPtrOutputWithContext(ctx context.Context) VolumeAttachPtrOutput

type VolumeAttachPtrInput added in v2.14.1 

type VolumeAttachPtrInput interface {
	pulumi.Input

	ToVolumeAttachPtrOutput() VolumeAttachPtrOutput
	ToVolumeAttachPtrOutputWithContext(ctx context.Context) VolumeAttachPtrOutput
}

type VolumeAttachPtrOutput added in v2.14.1 

type VolumeAttachPtrOutput struct {
	*pulumi.OutputState
}

func (VolumeAttachPtrOutput) ElementType added in v2.14.1 

func (VolumeAttachPtrOutput) ElementType() reflect.Type

func (VolumeAttachPtrOutput) ToVolumeAttachPtrOutput added in v2.14.1 

func (o VolumeAttachPtrOutput) ToVolumeAttachPtrOutput() VolumeAttachPtrOutput

func (VolumeAttachPtrOutput) ToVolumeAttachPtrOutputWithContext added in v2.14.1 

func (o VolumeAttachPtrOutput) ToVolumeAttachPtrOutputWithContext(ctx context.Context) VolumeAttachPtrOutput

type VolumeAttachState 

type VolumeAttachState struct {
	// See Argument Reference above. _NOTE_: The correctness of this
	// information is dependent upon the hypervisor in use. In some cases, this
	// should not be used as an authoritative piece of information.
	Device pulumi.StringPtrInput
	// The ID of the Instance to attach the Volume to.
	InstanceId pulumi.StringPtrInput
	// Enable attachment of multiattach-capable volumes.
	Multiattach pulumi.BoolPtrInput
	// The region in which to obtain the V2 Compute client.
	// A Compute client is needed to create a volume attachment. If omitted, the
	// `region` argument of the provider is used. Changing this creates a
	// new volume attachment.
	Region pulumi.StringPtrInput
	// Map of additional vendor-specific options.
	// Supported options are described below.
	VendorOptions VolumeAttachVendorOptionsPtrInput
	// The ID of the Volume to attach to an Instance.
	VolumeId pulumi.StringPtrInput
}

func (VolumeAttachState) ElementType 

func (VolumeAttachState) ElementType() reflect.Type

type VolumeAttachVendorOptions added in v2.11.0 

type VolumeAttachVendorOptions struct {
	// Boolean to control whether
	// to ignore volume status confirmation of the attached volume. This can be helpful
	// to work with some OpenStack clouds which don't have the Block Storage V3 API available.
	IgnoreVolumeConfirmation *bool `pulumi:"ignoreVolumeConfirmation"`
}

type VolumeAttachVendorOptionsArgs added in v2.11.0 

type VolumeAttachVendorOptionsArgs struct {
	// Boolean to control whether
	// to ignore volume status confirmation of the attached volume. This can be helpful
	// to work with some OpenStack clouds which don't have the Block Storage V3 API available.
	IgnoreVolumeConfirmation pulumi.BoolPtrInput `pulumi:"ignoreVolumeConfirmation"`
}

func (VolumeAttachVendorOptionsArgs) ElementType added in v2.11.0 

func (VolumeAttachVendorOptionsArgs) ElementType() reflect.Type

func (VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsOutput added in v2.11.0 

func (i VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsOutput() VolumeAttachVendorOptionsOutput

func (VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsOutputWithContext added in v2.11.0 

func (i VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsOutputWithContext(ctx context.Context) VolumeAttachVendorOptionsOutput

func (VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsPtrOutput added in v2.11.0 

func (i VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsPtrOutput() VolumeAttachVendorOptionsPtrOutput

func (VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsPtrOutputWithContext added in v2.11.0 

func (i VolumeAttachVendorOptionsArgs) ToVolumeAttachVendorOptionsPtrOutputWithContext(ctx context.Context) VolumeAttachVendorOptionsPtrOutput

type VolumeAttachVendorOptionsInput added in v2.11.0 

type VolumeAttachVendorOptionsInput interface {
	pulumi.Input

	ToVolumeAttachVendorOptionsOutput() VolumeAttachVendorOptionsOutput
	ToVolumeAttachVendorOptionsOutputWithContext(context.Context) VolumeAttachVendorOptionsOutput
}

VolumeAttachVendorOptionsInput is an input type that accepts VolumeAttachVendorOptionsArgs and VolumeAttachVendorOptionsOutput values. You can construct a concrete instance of `VolumeAttachVendorOptionsInput` via: 

VolumeAttachVendorOptionsArgs{...}

type VolumeAttachVendorOptionsOutput added in v2.11.0 

type VolumeAttachVendorOptionsOutput struct{ *pulumi.OutputState }

func (VolumeAttachVendorOptionsOutput) ElementType added in v2.11.0 

func (VolumeAttachVendorOptionsOutput) ElementType() reflect.Type

func (VolumeAttachVendorOptionsOutput) IgnoreVolumeConfirmation added in v2.11.0 

func (o VolumeAttachVendorOptionsOutput) IgnoreVolumeConfirmation() pulumi.BoolPtrOutput

Boolean to control whether to ignore volume status confirmation of the attached volume. This can be helpful to work with some OpenStack clouds which don't have the Block Storage V3 API available.

func (VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsOutput added in v2.11.0 

func (o VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsOutput() VolumeAttachVendorOptionsOutput

func (VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsOutputWithContext added in v2.11.0 

func (o VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsOutputWithContext(ctx context.Context) VolumeAttachVendorOptionsOutput

func (VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsPtrOutput added in v2.11.0 

func (o VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsPtrOutput() VolumeAttachVendorOptionsPtrOutput

func (VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsPtrOutputWithContext added in v2.11.0 

func (o VolumeAttachVendorOptionsOutput) ToVolumeAttachVendorOptionsPtrOutputWithContext(ctx context.Context) VolumeAttachVendorOptionsPtrOutput

type VolumeAttachVendorOptionsPtrInput added in v2.11.0 

type VolumeAttachVendorOptionsPtrInput interface {
	pulumi.Input

	ToVolumeAttachVendorOptionsPtrOutput() VolumeAttachVendorOptionsPtrOutput
	ToVolumeAttachVendorOptionsPtrOutputWithContext(context.Context) VolumeAttachVendorOptionsPtrOutput
}

VolumeAttachVendorOptionsPtrInput is an input type that accepts VolumeAttachVendorOptionsArgs, VolumeAttachVendorOptionsPtr and VolumeAttachVendorOptionsPtrOutput values. You can construct a concrete instance of `VolumeAttachVendorOptionsPtrInput` via: 

        VolumeAttachVendorOptionsArgs{...}

or:

        nil

func VolumeAttachVendorOptionsPtr added in v2.11.0 

func VolumeAttachVendorOptionsPtr(v *VolumeAttachVendorOptionsArgs) VolumeAttachVendorOptionsPtrInput

type VolumeAttachVendorOptionsPtrOutput added in v2.11.0 

type VolumeAttachVendorOptionsPtrOutput struct{ *pulumi.OutputState }

func (VolumeAttachVendorOptionsPtrOutput) Elem added in v2.11.0 

func (o VolumeAttachVendorOptionsPtrOutput) Elem() VolumeAttachVendorOptionsOutput

func (VolumeAttachVendorOptionsPtrOutput) ElementType added in v2.11.0 

func (VolumeAttachVendorOptionsPtrOutput) ElementType() reflect.Type

func (VolumeAttachVendorOptionsPtrOutput) IgnoreVolumeConfirmation added in v2.11.0 

func (o VolumeAttachVendorOptionsPtrOutput) IgnoreVolumeConfirmation() pulumi.BoolPtrOutput

Boolean to control whether to ignore volume status confirmation of the attached volume. This can be helpful to work with some OpenStack clouds which don't have the Block Storage V3 API available.

func (VolumeAttachVendorOptionsPtrOutput) ToVolumeAttachVendorOptionsPtrOutput added in v2.11.0 

func (o VolumeAttachVendorOptionsPtrOutput) ToVolumeAttachVendorOptionsPtrOutput() VolumeAttachVendorOptionsPtrOutput

func (VolumeAttachVendorOptionsPtrOutput) ToVolumeAttachVendorOptionsPtrOutputWithContext added in v2.11.0 

func (o VolumeAttachVendorOptionsPtrOutput) ToVolumeAttachVendorOptionsPtrOutputWithContext(ctx context.Context) VolumeAttachVendorOptionsPtrOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.