Module compute

@pulumi/openstack > compute

class Flavor

extends CustomResource

Manages a V2 flavor resource within OpenStack.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const test_flavor = new openstack.compute.Flavor("test-flavor", {
    disk: 20,
    extraSpecs: {
        "hw:cpu_policy": "CPU-POLICY",
        "hw:cpu_thread_policy": "CPU-THREAD-POLICY",
    },
    ram: 8096,
    vcpus: 2,
});

constructor

new Flavor(name: string, args: FlavorArgs, opts?: pulumi.CustomResourceOptions)

Create a Flavor resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: FlavorState, opts?: pulumi.CustomResourceOptions): Flavor

Get an existing Flavor resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property disk

public disk: pulumi.Output<number>;

The amount of disk space in gigabytes to use for the root (/) partition. Changing this creates a new flavor.

property ephemeral

public ephemeral: pulumi.Output<number | undefined>;

property extraSpecs

public extraSpecs: pulumi.Output<{[key: string]: any}>;

Key/Value pairs of metadata for the flavor.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property isPublic

public isPublic: pulumi.Output<boolean | undefined>;

Whether the flavor is public. Changing this creates a new flavor.

property name

public name: pulumi.Output<string>;

A unique name for the flavor. Changing this creates a new flavor.

property ram

public ram: pulumi.Output<number>;

The amount of RAM to use, in megabytes. Changing this creates a new flavor.

property region

public region: pulumi.Output<string>;

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.

property rxTxFactor

public rxTxFactor: pulumi.Output<number | undefined>;

RX/TX bandwith factor. The default is 1. Changing this creates a new flavor.

property swap

public swap: pulumi.Output<number | undefined>;

The amount of disk space in megabytes to use. If unspecified, the default is 0. Changing this creates a new flavor.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

property vcpus

public vcpus: pulumi.Output<number>;

The number of virtual CPUs to use. Changing this creates a new flavor.

class FlavorAccess

extends CustomResource

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

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const flavor1 = new openstack.compute.Flavor("flavor_1", {
    disk: 20,
    isPublic: false,
    ram: 8096,
    vcpus: 2,
});
const project1 = new openstack.identity.Project("project_1", {});
const access1 = new openstack.compute.FlavorAccess("access_1", {
    flavorId: flavor1.id,
    tenantId: project1.id,
});

constructor

new FlavorAccess(name: string, args: FlavorAccessArgs, opts?: pulumi.CustomResourceOptions)

Create a FlavorAccess resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: FlavorAccessState, opts?: pulumi.CustomResourceOptions): FlavorAccess

Get an existing FlavorAccess resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property flavorId

public flavorId: pulumi.Output<string>;

The UUID of flavor to use. Changing this creates a new flavor access.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property region

public region: pulumi.Output<string>;

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.

property tenantId

public tenantId: pulumi.Output<string>;

The UUID of tenant which is allowed to use the flavor. Changing this creates a new flavor access.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class FloatingIp

extends CustomResource

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 openstack_networking_floatingip_v2 resource instead, which uses the OpenStack Networking API.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const floatip1 = new openstack.compute.FloatingIp("floatip_1", {
    pool: "public",
});

constructor

new FloatingIp(name: string, args: FloatingIpArgs, opts?: pulumi.CustomResourceOptions)

Create a FloatingIp resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: FloatingIpState, opts?: pulumi.CustomResourceOptions): FloatingIp

Get an existing FloatingIp resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property address

public address: pulumi.Output<string>;

The actual floating IP address itself.

property fixedIp

public fixedIp: pulumi.Output<string>;

The fixed IP address corresponding to the floating IP.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property instanceId

public instanceId: pulumi.Output<string>;

UUID of the compute instance associated with the floating IP.

property pool

public pool: pulumi.Output<string>;

The name of the pool from which to obtain the floating IP. Changing this creates a new floating IP.

property region

public region: pulumi.Output<string>;

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).

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class FloatingIpAssociate

extends CustomResource

Associate a floating IP to an instance. This can be used instead of the floating_ip options in openstack_compute_instance_v2.

Example Usage

Automatically detect the correct network

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    securityGroups: ["default"],
});
const fip1FloatingIp = new openstack.networking.FloatingIp("fip_1", {
    pool: "my_pool",
});
const fip1FloatingIpAssociate = new openstack.compute.FloatingIpAssociate("fip_1", {
    floatingIp: fip1FloatingIp.address,
    instanceId: instance1.id,
});

Explicitly set the network to attach to

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    networks: [
        {
            name: "my_network",
        },
        {
            name: "default",
        },
    ],
    securityGroups: ["default"],
});
const fip1FloatingIp = new openstack.networking.FloatingIp("fip_1", {
    pool: "my_pool",
});
const fip1FloatingIpAssociate = new openstack.compute.FloatingIpAssociate("fip_1", {
    fixedIp: instance1.networks.apply(networks => networks[1].fixedIpV4),
    floatingIp: fip1FloatingIp.address,
    instanceId: instance1.id,
});

constructor

new FloatingIpAssociate(name: string, args: FloatingIpAssociateArgs, opts?: pulumi.CustomResourceOptions)

Create a FloatingIpAssociate resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: FloatingIpAssociateState, opts?: pulumi.CustomResourceOptions): FloatingIpAssociate

Get an existing FloatingIpAssociate resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property fixedIp

public fixedIp: pulumi.Output<string | undefined>;

The specific IP address to direct traffic to.

property floatingIp

public floatingIp: pulumi.Output<string>;

The floating IP to associate.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property instanceId

public instanceId: pulumi.Output<string>;

The instance to associte the floating IP with.

property region

public region: pulumi.Output<string>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

property waitUntilAssociated

public waitUntilAssociated: pulumi.Output<boolean | undefined>;

In cases where the OpenStack environment does not automatically wait until the association has finished, set this option to have Terraform poll the instance until the floating IP has been associated. Defaults to false.

class Instance

extends CustomResource

Manages a V2 VM instance resource within OpenStack.

Example Usage

Basic Instance

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const basic = new openstack.compute.Instance("basic", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    metadata: {
        this: "that",
    },
    networks: [{
        name: "my_network",
    }],
    securityGroups: ["default"],
});

Instance With Attached Volume

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const myvol = new openstack.blockstorage.VolumeV2("myvol", {
    size: 1,
});
const myinstance = new openstack.compute.Instance("myinstance", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    networks: [{
        name: "my_network",
    }],
    securityGroups: ["default"],
});
const attached = new openstack.compute.VolumeAttach("attached", {
    instanceId: myinstance.id,
    volumeId: myvol.id,
});

Boot From Volume

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const boot_from_volume = new openstack.compute.Instance("boot-from-volume", {
    blockDevices: [{
        bootIndex: 0,
        deleteOnTermination: true,
        destinationType: "volume",
        sourceType: "image",
        uuid: "<image-id>",
        volumeSize: 5,
    }],
    flavorId: "3",
    keyPair: "my_key_pair_name",
    networks: [{
        name: "my_network",
    }],
    securityGroups: ["default"],
});

Boot From an Existing Volume

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const myvol = new openstack.blockstorage.VolumeV1("myvol", {
    imageId: "<image-id>",
    size: 5,
});
const boot_from_volume = new openstack.compute.Instance("boot-from-volume", {
    blockDevices: [{
        bootIndex: 0,
        deleteOnTermination: true,
        destinationType: "volume",
        sourceType: "volume",
        uuid: myvol.id,
    }],
    flavorId: "3",
    keyPair: "my_key_pair_name",
    networks: [{
        name: "my_network",
    }],
    securityGroups: ["default"],
});

Boot Instance, Create Volume, and Attach Volume as a Block Device

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    blockDevices: [
        {
            bootIndex: 0,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "image",
            uuid: "<image-id>",
        },
        {
            bootIndex: 1,
            deleteOnTermination: true,
            destinationType: "volume",
            sourceType: "blank",
            volumeSize: 1,
        },
    ],
    flavorId: "3",
    imageId: "<image-id>",
    keyPair: "my_key_pair_name",
    securityGroups: ["default"],
});

Boot Instance and Attach Existing Volume as a Block Device

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const volume1 = new openstack.blockstorage.VolumeV2("volume_1", {
    size: 1,
});
const instance1 = new openstack.compute.Instance("instance_1", {
    blockDevices: [
        {
            bootIndex: 0,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "image",
            uuid: "<image-id>",
        },
        {
            bootIndex: 1,
            deleteOnTermination: true,
            destinationType: "volume",
            sourceType: "volume",
            uuid: volume1.id,
        },
    ],
    flavorId: "3",
    imageId: "<image-id>",
    keyPair: "my_key_pair_name",
    securityGroups: ["default"],
});

Instance With Multiple Networks

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const multi_net = new openstack.compute.Instance("multi-net", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    networks: [
        {
            name: "my_first_network",
        },
        {
            name: "my_second_network",
        },
    ],
    securityGroups: ["default"],
});
const myipFloatingIp = new openstack.networking.FloatingIp("myip", {
    pool: "my_pool",
});
const myipFloatingIpAssociate = new openstack.compute.FloatingIpAssociate("myip", {
    fixedIp: multi_net.networks.apply(networks => networks[1].fixedIpV4),
    floatingIp: myipFloatingIp.address,
    instanceId: multi_net.id,
});

Instance With Personality

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const personality = new openstack.compute.Instance("personality", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    networks: [{
        name: "my_network",
    }],
    personalities: [{
        content: "contents of file",
        file: "/path/to/file/on/instance.txt",
    }],
    securityGroups: ["default"],
});

Instance with Multiple Ephemeral Disks

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const multi_eph = new openstack.compute.Instance("multi-eph", {
    blockDevices: [
        {
            bootIndex: 0,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "image",
            uuid: "<image-id>",
        },
        {
            bootIndex: -1,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "blank",
            volumeSize: 1,
        },
        {
            bootIndex: -1,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "blank",
            volumeSize: 1,
        },
    ],
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    securityGroups: ["default"],
});

Instance with User Data (cloud-init)

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    networks: [{
        name: "my_network",
    }],
    securityGroups: ["default"],
    userData: `#cloud-config
hostname: instance_1.example.com
fqdn: instance_1.example.com`,
});

user_data can come from a variety of sources: inline, read in from the file function, or the template_cloudinit_config resource.

Notes

Multiple Ephemeral Disks

It’s possible to specify multiple block_device entries to create an instance with multiple ephemeral (local) disks. In order to create multiple ephemeral disks, the sum of the total amount of ephemeral space must be less than or equal to what the chosen flavor supports.

The following example shows how to create an instance with multiple ephemeral disks:

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const foo = new openstack.compute.Instance("foo", {
    blockDevices: [
        {
            bootIndex: 0,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "image",
            uuid: "<image uuid>",
        },
        {
            bootIndex: -1,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "blank",
            volumeSize: 1,
        },
        {
            bootIndex: -1,
            deleteOnTermination: true,
            destinationType: "local",
            sourceType: "blank",
            volumeSize: 1,
        },
    ],
    securityGroups: ["default"],
});

Instances and Security Groups

When referencing a security group resource in an instance resource, always use the name of the security group. If you specify the ID of the security group, Terraform will remove and reapply the security group upon each call. This is because the OpenStack Compute API returns the names of the associated security groups and not their IDs.

Note the following example:

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const sg1 = new openstack.networking.SecGroup("sg_1", {});
const foo = new openstack.compute.Instance("foo", {
    securityGroups: [sg1.name],
});

Instances and Ports

Neutron Ports are a great feature and provide a lot of functionality. However, there are some notes to be aware of when mixing Instances and Ports:

  • In OpenStack environments prior to the Kilo release, deleting or recreating an Instance will cause the Instance’s Port(s) to be deleted. One way of working around this is to taint any Port(s) used in Instances which are to be recreated. See here for further information.

  • When attaching an Instance to one or more networks using Ports, place the security groups on the Port and not the Instance. If you place the security groups on the Instance, the security groups will not be applied upon creation, but they will be applied upon a refresh. This is a known OpenStack bug.

  • Network IP information is not available within an instance for networks that are attached with Ports. This is mostly due to the flexibility Neutron Ports provide when it comes to IP addresses. For example, a Neutron Port can have multiple Fixed IP addresses associated with it. It’s not possible to know which single IP address the user would want returned to the Instance’s state information. Therefore, in order for a Provisioner to connect to an Instance via it’s network Port, customize the connection information:

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const port1 = new openstack.networking.Port("port_1", {
    adminStateUp: true,
    networkId: "0a1d0a27-cffa-4de3-92c5-9d3fd3f2e74d",
    securityGroupIds: [
        "2f02d20a-8dca-49b7-b26f-b6ce9fddaf4f",
        "ca1e5ed7-dae8-4605-987b-fadaeeb30461",
    ],
});
const instance1 = new openstack.compute.Instance("instance_1", {
    networks: [{
        port: port1.id,
    }],
});

constructor

new Instance(name: string, args?: InstanceArgs, opts?: pulumi.CustomResourceOptions)

Create a Instance resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: InstanceState, opts?: pulumi.CustomResourceOptions): Instance

Get an existing Instance resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property accessIpV4

public accessIpV4: pulumi.Output<string>;

The first detected Fixed IPv4 address.

property accessIpV6

public accessIpV6: pulumi.Output<string>;

The first detected Fixed IPv6 address.

property adminPass

public adminPass: pulumi.Output<string | undefined>;

The administrative password to assign to the server. Changing this changes the root password on the existing server.

property allMetadata

public allMetadata: pulumi.Output<{[key: string]: any}>;

Contains all instance metadata, even metadata not set by Terraform.

property availabilityZone

public availabilityZone: pulumi.Output<string>;

The availability zone in which to create the server. Changing this creates a new server.

property blockDevices

public blockDevices: pulumi.Output<{
    bootIndex: number;
    deleteOnTermination: boolean;
    destinationType: string;
    deviceType: string;
    diskBus: string;
    guestFormat: string;
    sourceType: string;
    uuid: string;
    volumeSize: number;
}[] | undefined>;

Configuration of block devices. The block_device 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 for more information.

property configDrive

public configDrive: pulumi.Output<boolean | undefined>;

Whether to use the config_drive feature to configure the instance. Changing this creates a new server.

property flavorId

public flavorId: pulumi.Output<string>;

The flavor ID of the desired flavor for the server. Changing this resizes the existing server.

property flavorName

public flavorName: pulumi.Output<string>;

The name of the desired flavor for the server. Changing this resizes the existing server.

property forceDelete

public forceDelete: pulumi.Output<boolean | undefined>;

Whether to force the OpenStack instance to be forcefully deleted. This is useful for environments that have reclaim / soft deletion enabled.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property imageId

public imageId: pulumi.Output<string>;

(Optional; Required if image_name 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.

property imageName

public imageName: pulumi.Output<string>;

(Optional; Required if image_id 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.

property keyPair

public keyPair: pulumi.Output<string | undefined>;

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.

property metadata

public metadata: pulumi.Output<{[key: string]: any} | undefined>;

Metadata key/value pairs to make available from within the instance. Changing this updates the existing server metadata.

property name

public name: pulumi.Output<string>;

A unique name for the resource.

property networks

public networks: pulumi.Output<{
    accessNetwork: boolean;
    fixedIpV4: string;
    fixedIpV6: string;
    mac: string;
    name: string;
    port: string;
    uuid: string;
}[]>;

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.

property personalities

public personalities: pulumi.Output<{
    content: string;
    file: string;
}[] | undefined>;

Customize the personality of an instance by defining one or more files and their contents. The personality structure is described below.

property powerState

public powerState: pulumi.Output<string | undefined>;

Provide the VM state. Only ‘active’ and ‘shutoff’ are supported values. Note: If the initial power_state is the shutoff the VM will be stopped immediately after build and the provisioners like remote-exec or files are not supported.

property region

public region: pulumi.Output<string>;

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.

property schedulerHints

public schedulerHints: pulumi.Output<{
    additionalProperties: {[key: string]: any};
    buildNearHostIp: string;
    differentHosts: string[];
    group: string;
    queries: string[];
    sameHosts: string[];
    targetCell: string;
}[] | undefined>;

Provide the Nova scheduler with hints on how the instance should be launched. The available hints are described below.

property securityGroups

public securityGroups: pulumi.Output<string[]>;

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.

property stopBeforeDestroy

public stopBeforeDestroy: pulumi.Output<boolean | undefined>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

property userData

public userData: pulumi.Output<string | undefined>;

The user data to provide when launching the instance. Changing this creates a new server.

property vendorOptions

public vendorOptions: pulumi.Output<{
    ignoreResizeConfirmation: boolean;
} | undefined>;

Map of additional vendor-specific options. Supported options are described below.

class InterfaceAttach

extends CustomResource

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

Example Usage

Basic Attachment

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const network1 = new openstack.networking.Network("network_1", {
    adminStateUp: true,
});
const ai1 = new openstack.compute.InterfaceAttach("ai_1", {
    instanceId: instance1.id,
    networkId: openstack_networking_port_v2_network_1.id,
});

Attachment Specifying a Fixed IP

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const network1 = new openstack.networking.Network("network_1", {
    adminStateUp: true,
});
const ai1 = new openstack.compute.InterfaceAttach("ai_1", {
    fixedIp: "10.0.10.10",
    instanceId: instance1.id,
    networkId: openstack_networking_port_v2_network_1.id,
});

Attachment Using an Existing Port

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const network1 = new openstack.networking.Network("network_1", {
    adminStateUp: true,
});
const port1 = new openstack.networking.Port("port_1", {
    adminStateUp: true,
    networkId: network1.id,
});
const ai1 = new openstack.compute.InterfaceAttach("ai_1", {
    instanceId: instance1.id,
    portId: port1.id,
});

Attaching Multiple Interfaces

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const network1 = new openstack.networking.Network("network_1", {
    adminStateUp: true,
});
const ports: openstack.networking.Port[] = [];
for (let i = 0; i < 2; i++) {
    ports.push(new openstack.networking.Port(`ports-${i}`, {
        adminStateUp: true,
        networkId: network1.id,
    }));
}
const attachments: openstack.compute.InterfaceAttach[] = [];
for (let i = 0; i < 2; i++) {
    attachments.push(new openstack.compute.InterfaceAttach(`attachments-${i}`, {
        instanceId: instance1.id,
        portId: pulumi.all(ports.map(v => v.id)).apply(id => id.map(v => v)[i]),
    }));
}

Note that the above example will not guarantee that the ports are attached in a deterministic manner. The ports will be attached in a seemingly random order.

If you want to ensure that the ports are attached in a given order, create explicit dependencies between the ports, such as:

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const network1 = new openstack.networking.Network("network_1", {
    adminStateUp: true,
});
const ports: openstack.networking.Port[] = [];
for (let i = 0; i < 2; i++) {
    ports.push(new openstack.networking.Port(`ports-${i}`, {
        adminStateUp: true,
        networkId: network1.id,
    }));
}
const ai1 = new openstack.compute.InterfaceAttach("ai_1", {
    instanceId: instance1.id,
    portId: pulumi.all(ports.map(v => v.id)).apply(id => id.map(v => v)[0]),
});
const ai2 = new openstack.compute.InterfaceAttach("ai_2", {
    instanceId: instance1.id,
    portId: pulumi.all(ports.map(v => v.id)).apply(id => id.map(v => v)[1]),
});

constructor

new InterfaceAttach(name: string, args: InterfaceAttachArgs, opts?: pulumi.CustomResourceOptions)

Create a InterfaceAttach resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: InterfaceAttachState, opts?: pulumi.CustomResourceOptions): InterfaceAttach

Get an existing InterfaceAttach resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property fixedIp

public fixedIp: pulumi.Output<string | undefined>;

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.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property instanceId

public instanceId: pulumi.Output<string>;

The ID of the Instance to attach the Port or Network to.

property networkId

public networkId: pulumi.Output<string>;

The ID of the Network to attach to an Instance. A port will be created automatically. NOTE: This option and port_id are mutually exclusive.

property portId

public portId: pulumi.Output<string>;

The ID of the Port to attach to an Instance. NOTE: This option and network_id are mutually exclusive.

property region

public region: pulumi.Output<string>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class Keypair

extends CustomResource

Manages a V2 keypair resource within OpenStack.

Important Security Notice The private key generated by this resource will be stored unencrypted in your Terraform state file. Use of this resource for production deployments is not recommended. Instead, generate a private key file outside of Terraform and distribute it securely to the system where Terraform will be run.

Example Usage

Import an Existing Public Key

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const test_keypair = new openstack.compute.Keypair("test-keypair", {
    publicKey: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDAjpC1hwiOCCmKEWxJ4qzTTsJbKzndLotBCz5PcwtUnflmU+gHJtWMZKpuEGVi29h0A/+ydKek1O18k10Ff+4tyFjiHDQAnOfgWf7+b1yK+qDip3X1C0UPMbwHlTfSGWLGZqd9LvEFx9k3h/M+VtMvwR1lJ9LUyTAImnNjWG7TaIPmui30HvM2UiFEmqkr4ijq45MyX2+fLIePLRIF61p4whjHAQYufqyno3BS48icQb4p6iVEZPo4AE2o9oIyQvj2mx4dk5Y8CgSETOZTYDOR3rU2fZTRDRgPJDH9FWvQjF5tA0p3d9CoWWd2s6GKKbfoUIi8R/Db1BSPJwkqB",
});

Generate a Public/Private Key Pair

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const test_keypair = new openstack.compute.Keypair("test-keypair", {});

constructor

new Keypair(name: string, args?: KeypairArgs, opts?: pulumi.CustomResourceOptions)

Create a Keypair resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: KeypairState, opts?: pulumi.CustomResourceOptions): Keypair

Get an existing Keypair resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property fingerprint

public fingerprint: pulumi.Output<string>;

The fingerprint of the public key.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property name

public name: pulumi.Output<string>;

A unique name for the keypair. Changing this creates a new keypair.

property privateKey

public privateKey: pulumi.Output<string>;

The generated private key when no public key is specified.

property publicKey

public publicKey: pulumi.Output<string>;

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.

property region

public region: pulumi.Output<string>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

property valueSpecs

public valueSpecs: pulumi.Output<{[key: string]: any} | undefined>;

Map of additional options.

class SecGroup

extends CustomResource

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 openstack_networking_secgroup_v2 and openstack_networking_secgroup_rule_v2 resources instead, which uses the OpenStack Networking API.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const secgroup1 = new openstack.compute.SecGroup("secgroup_1", {
    description: "my security group",
    rules: [
        {
            cidr: "0.0.0.0/0",
            fromPort: 22,
            ipProtocol: "tcp",
            toPort: 22,
        },
        {
            cidr: "0.0.0.0/0",
            fromPort: 80,
            ipProtocol: "tcp",
            toPort: 80,
        },
    ],
});

Notes

ICMP Rules

When using ICMP as the ip_protocol, the from_port sets the ICMP type and the to_port sets the ICMP code. To allow all ICMP types, set each value to -1, like so:

import * as pulumi from "@pulumi/pulumi";

A list of ICMP types and codes can be found here.

Referencing Security Groups

When referencing a security group in a configuration (for example, a configuration creates a new security group and then needs to apply it to an instance being created in the same configuration), it is currently recommended to reference the security group by name and not by ID, like this:

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const test_server = new openstack.compute.Instance("test-server", {
    flavorId: "3",
    imageId: "ad091b52-742f-469e-8f3c-fd81cadf0743",
    keyPair: "my_key_pair_name",
    securityGroups: [openstack_compute_secgroup_v2_secgroup_1.name],
});

constructor

new SecGroup(name: string, args: SecGroupArgs, opts?: pulumi.CustomResourceOptions)

Create a SecGroup resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: SecGroupState, opts?: pulumi.CustomResourceOptions): SecGroup

Get an existing SecGroup resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property description

public description: pulumi.Output<string>;

A description for the security group. Changing this updates the description of an existing security group.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property name

public name: pulumi.Output<string>;

A unique name for the security group. Changing this updates the name of an existing security group.

property region

public region: pulumi.Output<string>;

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.

property rules

public rules: pulumi.Output<{
    cidr: string;
    fromGroupId: string;
    fromPort: number;
    id: string;
    ipProtocol: string;
    self: boolean;
    toPort: number;
}[]>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class ServerGroup

extends CustomResource

Manages a V2 Server Group resource within OpenStack.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const test_sg = new openstack.compute.ServerGroup("test-sg", {
    policies: ["anti-affinity"],
});

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.

constructor

new ServerGroup(name: string, args?: ServerGroupArgs, opts?: pulumi.CustomResourceOptions)

Create a ServerGroup resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: ServerGroupState, opts?: pulumi.CustomResourceOptions): ServerGroup

Get an existing ServerGroup resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property members

public members: pulumi.Output<string[]>;

The instances that are part of this server group.

property name

public name: pulumi.Output<string>;

A unique name for the server group. Changing this creates a new server group.

property policies

public policies: pulumi.Output<string[] | undefined>;

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.

property region

public region: pulumi.Output<string>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

property valueSpecs

public valueSpecs: pulumi.Output<{[key: string]: any} | undefined>;

Map of additional options.

class VolumeAttach

extends CustomResource

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

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const volume1 = new openstack.blockstorage.VolumeV2("volume_1", {
    size: 1,
});
const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const va1 = new openstack.compute.VolumeAttach("va_1", {
    instanceId: instance1.id,
    volumeId: volume1.id,
});

Attaching multiple volumes to a single instance

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const volumes: openstack.blockstorage.VolumeV2[] = [];
for (let i = 0; i < 2; i++) {
    volumes.push(new openstack.blockstorage.VolumeV2(`volumes-${i}`, {
        size: 1,
    }));
}
const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const attachments: openstack.compute.VolumeAttach[] = [];
for (let i = 0; i < 2; i++) {
    attachments.push(new openstack.compute.VolumeAttach(`attachments-${i}`, {
        instanceId: instance1.id,
        volumeId: pulumi.all(volumes.map(v => v.id)).apply(id => id.map(v => v)[i]),
    }));
}

export const volume_devices = attachments.map(v => v.device);

Note that the above example will not guarantee that the volumes are attached in a deterministic manner. The volumes will be attached in a seemingly random order.

If you want to ensure that the volumes are attached in a given order, create explicit dependencies between the volumes, such as:

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const volumes: openstack.blockstorage.VolumeV2[] = [];
for (let i = 0; i < 2; i++) {
    volumes.push(new openstack.blockstorage.VolumeV2(`volumes-${i}`, {
        size: 1,
    }));
}
const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const attach1 = new openstack.compute.VolumeAttach("attach_1", {
    instanceId: instance1.id,
    volumeId: volumes[0].id,
});
const attach2 = new openstack.compute.VolumeAttach("attach_2", {
    instanceId: instance1.id,
    volumeId: volumes[1].id,
}, {dependsOn: [attach1]});

export const volume_devices = openstack_compute_volume_attach_v2_attachments.map(v => v.device);

Using Multiattach-enabled volumes

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

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const volume1 = new openstack.blockstorage.Volume("volume_1", {
    multiattach: true,
    size: 1,
});
const instance1 = new openstack.compute.Instance("instance_1", {
    securityGroups: ["default"],
});
const instance2 = new openstack.compute.Instance("instance_2", {
    securityGroups: ["default"],
});
const va1 = new openstack.compute.VolumeAttach("va_1", {
    instanceId: instance1.id,
    multiattach: true,
    volumeId: openstack_blockstorage_volume_v2_volume_1.id,
});
const va2 = new openstack.compute.VolumeAttach("va_2", {
    instanceId: instance2.id,
    multiattach: true,
    volumeId: openstack_blockstorage_volume_v2_volume_1.id,
}, {dependsOn: [va1]});

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

constructor

new VolumeAttach(name: string, args: VolumeAttachArgs, opts?: pulumi.CustomResourceOptions)

Create a VolumeAttach resource with the given unique name, arguments, and options.

  • name The unique name of the resource.
  • args The arguments to use to populate this resource's properties.
  • opts A bag of options that control this resource's behavior.

method get

public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: VolumeAttachState, opts?: pulumi.CustomResourceOptions): VolumeAttach

Get an existing VolumeAttach resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

Returns true if the given object is an instance of CustomResource. This is designed to work even when multiple copies of the Pulumi SDK have been loaded into the same process.

property device

public device: pulumi.Output<string>;

The device of the volume attachment (ex: /dev/vdc). NOTE: Being able to specify a device is dependent upon the hypervisor in use. There is a chance that the device specified in Terraform will not be the same device the hypervisor chose. If this happens, Terraform will wish to update the device upon subsequent applying which will cause the volume to be detached and reattached indefinitely. Please use with caution.

property id

id: Output<ID>;

id is the provider-assigned unique ID for this managed resource. It is set during deployments and may be missing (undefined) during planning phases.

property instanceId

public instanceId: pulumi.Output<string>;

The ID of the Instance to attach the Volume to.

property multiattach

public multiattach: pulumi.Output<boolean | undefined>;

Enable attachment of multiattach-capable volumes.

property region

public region: pulumi.Output<string>;

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.

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

property volumeId

public volumeId: pulumi.Output<string>;

The ID of the Volume to attach to an Instance.

function getAvailabilityZones

getAvailabilityZones(args?: GetAvailabilityZonesArgs, opts?: pulumi.InvokeOptions): Promise<GetAvailabilityZonesResult>

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

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const zones = pulumi.output(openstack.compute.getAvailabilityZones({}));

function getFlavor

getFlavor(args?: GetFlavorArgs, opts?: pulumi.InvokeOptions): Promise<GetFlavorResult>

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

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const small = pulumi.output(openstack.compute.getFlavor({
    ram: 512,
    vcpus: 1,
}));

function getKeypair

getKeypair(args: GetKeypairArgs, opts?: pulumi.InvokeOptions): Promise<GetKeypairResult>

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

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as openstack from "@pulumi/openstack";

const kp = pulumi.output(openstack.compute.getKeypair({
    name: "sand",
}));

interface FlavorAccessArgs

The set of arguments for constructing a FlavorAccess resource.

property flavorId

flavorId: pulumi.Input<string>;

The UUID of flavor to use. Changing this creates a new flavor access.

property region

region?: pulumi.Input<string>;

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.

property tenantId

tenantId: pulumi.Input<string>;

The UUID of tenant which is allowed to use the flavor. Changing this creates a new flavor access.

interface FlavorAccessState

Input properties used for looking up and filtering FlavorAccess resources.

property flavorId

flavorId?: pulumi.Input<string>;

The UUID of flavor to use. Changing this creates a new flavor access.

property region

region?: pulumi.Input<string>;

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.

property tenantId

tenantId?: pulumi.Input<string>;

The UUID of tenant which is allowed to use the flavor. Changing this creates a new flavor access.

interface FlavorArgs

The set of arguments for constructing a Flavor resource.

property disk

disk: pulumi.Input<number>;

The amount of disk space in gigabytes to use for the root (/) partition. Changing this creates a new flavor.

property ephemeral

ephemeral?: pulumi.Input<number>;

property extraSpecs

extraSpecs?: pulumi.Input<{[key: string]: any}>;

Key/Value pairs of metadata for the flavor.

property isPublic

isPublic?: pulumi.Input<boolean>;

Whether the flavor is public. Changing this creates a new flavor.

property name

name?: pulumi.Input<string>;

A unique name for the flavor. Changing this creates a new flavor.

property ram

ram: pulumi.Input<number>;

The amount of RAM to use, in megabytes. Changing this creates a new flavor.

property region

region?: pulumi.Input<string>;

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.

property rxTxFactor

rxTxFactor?: pulumi.Input<number>;

RX/TX bandwith factor. The default is 1. Changing this creates a new flavor.

property swap

swap?: pulumi.Input<number>;

The amount of disk space in megabytes to use. If unspecified, the default is 0. Changing this creates a new flavor.

property vcpus

vcpus: pulumi.Input<number>;

The number of virtual CPUs to use. Changing this creates a new flavor.

interface FlavorState

Input properties used for looking up and filtering Flavor resources.

property disk

disk?: pulumi.Input<number>;

The amount of disk space in gigabytes to use for the root (/) partition. Changing this creates a new flavor.

property ephemeral

ephemeral?: pulumi.Input<number>;

property extraSpecs

extraSpecs?: pulumi.Input<{[key: string]: any}>;

Key/Value pairs of metadata for the flavor.

property isPublic

isPublic?: pulumi.Input<boolean>;

Whether the flavor is public. Changing this creates a new flavor.

property name

name?: pulumi.Input<string>;

A unique name for the flavor. Changing this creates a new flavor.

property ram

ram?: pulumi.Input<number>;

The amount of RAM to use, in megabytes. Changing this creates a new flavor.

property region

region?: pulumi.Input<string>;

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.

property rxTxFactor

rxTxFactor?: pulumi.Input<number>;

RX/TX bandwith factor. The default is 1. Changing this creates a new flavor.

property swap

swap?: pulumi.Input<number>;

The amount of disk space in megabytes to use. If unspecified, the default is 0. Changing this creates a new flavor.

property vcpus

vcpus?: pulumi.Input<number>;

The number of virtual CPUs to use. Changing this creates a new flavor.

interface FloatingIpArgs

The set of arguments for constructing a FloatingIp resource.

property pool

pool: pulumi.Input<string>;

The name of the pool from which to obtain the floating IP. Changing this creates a new floating IP.

property region

region?: pulumi.Input<string>;

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).

interface FloatingIpAssociateArgs

The set of arguments for constructing a FloatingIpAssociate resource.

property fixedIp

fixedIp?: pulumi.Input<string>;

The specific IP address to direct traffic to.

property floatingIp

floatingIp: pulumi.Input<string>;

The floating IP to associate.

property instanceId

instanceId: pulumi.Input<string>;

The instance to associte the floating IP with.

property region

region?: pulumi.Input<string>;

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.

property waitUntilAssociated

waitUntilAssociated?: pulumi.Input<boolean>;

In cases where the OpenStack environment does not automatically wait until the association has finished, set this option to have Terraform poll the instance until the floating IP has been associated. Defaults to false.

interface FloatingIpAssociateState

Input properties used for looking up and filtering FloatingIpAssociate resources.

property fixedIp

fixedIp?: pulumi.Input<string>;

The specific IP address to direct traffic to.

property floatingIp

floatingIp?: pulumi.Input<string>;

The floating IP to associate.

property instanceId

instanceId?: pulumi.Input<string>;

The instance to associte the floating IP with.

property region

region?: pulumi.Input<string>;

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.

property waitUntilAssociated

waitUntilAssociated?: pulumi.Input<boolean>;

In cases where the OpenStack environment does not automatically wait until the association has finished, set this option to have Terraform poll the instance until the floating IP has been associated. Defaults to false.

interface FloatingIpState

Input properties used for looking up and filtering FloatingIp resources.

property address

address?: pulumi.Input<string>;

The actual floating IP address itself.

property fixedIp

fixedIp?: pulumi.Input<string>;

The fixed IP address corresponding to the floating IP.

property instanceId

instanceId?: pulumi.Input<string>;

UUID of the compute instance associated with the floating IP.

property pool

pool?: pulumi.Input<string>;

The name of the pool from which to obtain the floating IP. Changing this creates a new floating IP.

property region

region?: pulumi.Input<string>;

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).

interface GetAvailabilityZonesArgs

A collection of arguments for invoking getAvailabilityZones.

property region

region?: string;

The region to fetch availability zones from, defaults to the provider’s region

property state

state?: string;

The state of the availability zones to match, default (“available”).

interface GetAvailabilityZonesResult

A collection of values returned by getAvailabilityZones.

property id

id: string;

id is the provider-assigned unique ID for this managed resource.

property names

names: string[];

The names of the availability zones, ordered alphanumerically, that match the queried state

property region

region: string;

property state

state?: string;

interface GetFlavorArgs

A collection of arguments for invoking getFlavor.

property disk

disk?: number;

The exact amount of disk (in gigabytes).

property flavorId

flavorId?: string;

The ID of the flavor. Conflicts with the name, min_ram and min_disk

property minDisk

minDisk?: number;

The minimum amount of disk (in gigabytes). Conflicts with the flavor_id.

property minRam

minRam?: number;

The minimum amount of RAM (in megabytes). Conflicts with the flavor_id.

property name

name?: string;

The name of the flavor. Conflicts with the flavor_id.

property ram

ram?: number;

The exact amount of RAM (in megabytes).

property region

region?: string;

The region in which to obtain the V2 Compute client. If omitted, the region argument of the provider is used.

property rxTxFactor

rxTxFactor?: number;

The rx_tx_factor of the flavor.

property swap

swap?: number;

The amount of swap (in gigabytes).

property vcpus

vcpus?: number;

The amount of VCPUs.

interface GetFlavorResult

A collection of values returned by getFlavor.

property disk

disk?: number;

property extraSpecs

extraSpecs: {[key: string]: any};

Key/Value pairs of metadata for the flavor.

property flavorId

flavorId?: string;

property id

id: string;

id is the provider-assigned unique ID for this managed resource.

property isPublic

isPublic: boolean;

Whether the flavor is public or private.

property minDisk

minDisk?: number;

property minRam

minRam?: number;

property name

name?: string;

property ram

ram?: number;

property region

region: string;

property rxTxFactor

rxTxFactor?: number;

property swap

swap?: number;

property vcpus

vcpus?: number;

interface GetKeypairArgs

A collection of arguments for invoking getKeypair.

property name

name: string;

The unique name of the keypair.

property region

region?: string;

The region in which to obtain the V2 Compute client. If omitted, the region argument of the provider is used.

interface GetKeypairResult

A collection of values returned by getKeypair.

property fingerprint

fingerprint: string;

The fingerprint of the OpenSSH key.

property id

id: string;

id is the provider-assigned unique ID for this managed resource.

property name

name: string;

See Argument Reference above.

property publicKey

publicKey: string;

The OpenSSH-formatted public key of the keypair.

property region

region: string;

See Argument Reference above.

interface InstanceArgs

The set of arguments for constructing a Instance resource.

property accessIpV4

accessIpV4?: pulumi.Input<string>;

The first detected Fixed IPv4 address.

property accessIpV6

accessIpV6?: pulumi.Input<string>;

The first detected Fixed IPv6 address.

property adminPass

adminPass?: pulumi.Input<string>;

The administrative password to assign to the server. Changing this changes the root password on the existing server.

property availabilityZone

availabilityZone?: pulumi.Input<string>;

The availability zone in which to create the server. Changing this creates a new server.

property blockDevices

blockDevices?: pulumi.Input<pulumi.Input<{
    bootIndex: pulumi.Input<number>;
    deleteOnTermination: pulumi.Input<boolean>;
    destinationType: pulumi.Input<string>;
    deviceType: pulumi.Input<string>;
    diskBus: pulumi.Input<string>;
    guestFormat: pulumi.Input<string>;
    sourceType: pulumi.Input<string>;
    uuid: pulumi.Input<string>;
    volumeSize: pulumi.Input<number>;
}>[]>;

Configuration of block devices. The block_device 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 for more information.

property configDrive

configDrive?: pulumi.Input<boolean>;

Whether to use the config_drive feature to configure the instance. Changing this creates a new server.

property flavorId

flavorId?: pulumi.Input<string>;

The flavor ID of the desired flavor for the server. Changing this resizes the existing server.

property flavorName

flavorName?: pulumi.Input<string>;

The name of the desired flavor for the server. Changing this resizes the existing server.

property forceDelete

forceDelete?: pulumi.Input<boolean>;

Whether to force the OpenStack instance to be forcefully deleted. This is useful for environments that have reclaim / soft deletion enabled.

property imageId

imageId?: pulumi.Input<string>;

(Optional; Required if image_name 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.

property imageName

imageName?: pulumi.Input<string>;

(Optional; Required if image_id 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.

property keyPair

keyPair?: pulumi.Input<string>;

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.

property metadata

metadata?: pulumi.Input<{[key: string]: any}>;

Metadata key/value pairs to make available from within the instance. Changing this updates the existing server metadata.

property name

name?: pulumi.Input<string>;

A unique name for the resource.

property networks

networks?: pulumi.Input<pulumi.Input<{
    accessNetwork: pulumi.Input<boolean>;
    fixedIpV4: pulumi.Input<string>;
    fixedIpV6: pulumi.Input<string>;
    mac: pulumi.Input<string>;
    name: pulumi.Input<string>;
    port: pulumi.Input<string>;
    uuid: pulumi.Input<string>;
}>[]>;

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.

property personalities

personalities?: pulumi.Input<pulumi.Input<{
    content: pulumi.Input<string>;
    file: pulumi.Input<string>;
}>[]>;

Customize the personality of an instance by defining one or more files and their contents. The personality structure is described below.

property powerState

powerState?: pulumi.Input<string>;

Provide the VM state. Only ‘active’ and ‘shutoff’ are supported values. Note: If the initial power_state is the shutoff the VM will be stopped immediately after build and the provisioners like remote-exec or files are not supported.

property region

region?: pulumi.Input<string>;

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.

property schedulerHints

schedulerHints?: pulumi.Input<pulumi.Input<{
    additionalProperties: pulumi.Input<{[key: string]: any}>;
    buildNearHostIp: pulumi.Input<string>;
    differentHosts: pulumi.Input<pulumi.Input<string>[]>;
    group: pulumi.Input<string>;
    queries: pulumi.Input<pulumi.Input<string>[]>;
    sameHosts: pulumi.Input<pulumi.Input<string>[]>;
    targetCell: pulumi.Input<string>;
}>[]>;

Provide the Nova scheduler with hints on how the instance should be launched. The available hints are described below.

property securityGroups

securityGroups?: pulumi.Input<pulumi.Input<string>[]>;

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.

property stopBeforeDestroy

stopBeforeDestroy?: pulumi.Input<boolean>;

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.

property userData

userData?: pulumi.Input<string>;

The user data to provide when launching the instance. Changing this creates a new server.

property vendorOptions

vendorOptions?: pulumi.Input<{
    ignoreResizeConfirmation: pulumi.Input<boolean>;
}>;

Map of additional vendor-specific options. Supported options are described below.

interface InstanceState

Input properties used for looking up and filtering Instance resources.

property accessIpV4

accessIpV4?: pulumi.Input<string>;

The first detected Fixed IPv4 address.

property accessIpV6

accessIpV6?: pulumi.Input<string>;

The first detected Fixed IPv6 address.

property adminPass

adminPass?: pulumi.Input<string>;

The administrative password to assign to the server. Changing this changes the root password on the existing server.

property allMetadata

allMetadata?: pulumi.Input<{[key: string]: any}>;

Contains all instance metadata, even metadata not set by Terraform.

property availabilityZone

availabilityZone?: pulumi.Input<string>;

The availability zone in which to create the server. Changing this creates a new server.

property blockDevices

blockDevices?: pulumi.Input<pulumi.Input<{
    bootIndex: pulumi.Input<number>;
    deleteOnTermination: pulumi.Input<boolean>;
    destinationType: pulumi.Input<string>;
    deviceType: pulumi.Input<string>;
    diskBus: pulumi.Input<string>;
    guestFormat: pulumi.Input<string>;
    sourceType: pulumi.Input<string>;
    uuid: pulumi.Input<string>;
    volumeSize: pulumi.Input<number>;
}>[]>;

Configuration of block devices. The block_device 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 for more information.

property configDrive

configDrive?: pulumi.Input<boolean>;

Whether to use the config_drive feature to configure the instance. Changing this creates a new server.

property flavorId

flavorId?: pulumi.Input<string>;

The flavor ID of the desired flavor for the server. Changing this resizes the existing server.

property flavorName

flavorName?: pulumi.Input<string>;

The name of the desired flavor for the server. Changing this resizes the existing server.

property forceDelete

forceDelete?: pulumi.Input<boolean>;

Whether to force the OpenStack instance to be forcefully deleted. This is useful for environments that have reclaim / soft deletion enabled.

property imageId

imageId?: pulumi.Input<string>;

(Optional; Required if image_name 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.

property imageName

imageName?: pulumi.Input<string>;

(Optional; Required if image_id 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.

property keyPair

keyPair?: pulumi.Input<string>;

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.

property metadata

metadata?: pulumi.Input<{[key: string]: any}>;

Metadata key/value pairs to make available from within the instance. Changing this updates the existing server metadata.

property name

name?: pulumi.Input<string>;

A unique name for the resource.

property networks

networks?: pulumi.Input<pulumi.Input<{
    accessNetwork: pulumi.Input<boolean>;
    fixedIpV4: pulumi.Input<string>;
    fixedIpV6: pulumi.Input<string>;
    mac: pulumi.Input<string>;
    name: pulumi.Input<string>;
    port: pulumi.Input<string>;
    uuid: pulumi.Input<string>;
}>[]>;

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.

property personalities

personalities?: pulumi.Input<pulumi.Input<{
    content: pulumi.Input<string>;
    file: pulumi.Input<string>;
}>[]>;

Customize the personality of an instance by defining one or more files and their contents. The personality structure is described below.

property powerState

powerState?: pulumi.Input<string>;

Provide the VM state. Only ‘active’ and ‘shutoff’ are supported values. Note: If the initial power_state is the shutoff the VM will be stopped immediately after build and the provisioners like remote-exec or files are not supported.

property region

region?: pulumi.Input<string>;

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.

property schedulerHints

schedulerHints?: pulumi.Input<pulumi.Input<{
    additionalProperties: pulumi.Input<{[key: string]: any}>;
    buildNearHostIp: pulumi.Input<string>;
    differentHosts: pulumi.Input<pulumi.Input<string>[]>;
    group: pulumi.Input<string>;
    queries: pulumi.Input<pulumi.Input<string>[]>;
    sameHosts: pulumi.Input<pulumi.Input<string>[]>;
    targetCell: pulumi.Input<string>;
}>[]>;

Provide the Nova scheduler with hints on how the instance should be launched. The available hints are described below.

property securityGroups

securityGroups?: pulumi.Input<pulumi.Input<string>[]>;

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.

property stopBeforeDestroy

stopBeforeDestroy?: pulumi.Input<boolean>;

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.

property userData

userData?: pulumi.Input<string>;

The user data to provide when launching the instance. Changing this creates a new server.

property vendorOptions

vendorOptions?: pulumi.Input<{
    ignoreResizeConfirmation: pulumi.Input<boolean>;
}>;

Map of additional vendor-specific options. Supported options are described below.

interface InterfaceAttachArgs

The set of arguments for constructing a InterfaceAttach resource.

property fixedIp

fixedIp?: pulumi.Input<string>;

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.

property instanceId

instanceId: pulumi.Input<string>;

The ID of the Instance to attach the Port or Network to.

property networkId

networkId?: pulumi.Input<string>;

The ID of the Network to attach to an Instance. A port will be created automatically. NOTE: This option and port_id are mutually exclusive.

property portId

portId?: pulumi.Input<string>;

The ID of the Port to attach to an Instance. NOTE: This option and network_id are mutually exclusive.

property region

region?: pulumi.Input<string>;

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.

interface InterfaceAttachState

Input properties used for looking up and filtering InterfaceAttach resources.

property fixedIp

fixedIp?: pulumi.Input<string>;

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.

property instanceId

instanceId?: pulumi.Input<string>;

The ID of the Instance to attach the Port or Network to.

property networkId

networkId?: pulumi.Input<string>;

The ID of the Network to attach to an Instance. A port will be created automatically. NOTE: This option and port_id are mutually exclusive.

property portId

portId?: pulumi.Input<string>;

The ID of the Port to attach to an Instance. NOTE: This option and network_id are mutually exclusive.

property region

region?: pulumi.Input<string>;

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.

interface KeypairArgs

The set of arguments for constructing a Keypair resource.

property name

name?: pulumi.Input<string>;

A unique name for the keypair. Changing this creates a new keypair.

property publicKey

publicKey?: pulumi.Input<string>;

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.

property region

region?: pulumi.Input<string>;

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.

property valueSpecs

valueSpecs?: pulumi.Input<{[key: string]: any}>;

Map of additional options.

interface KeypairState

Input properties used for looking up and filtering Keypair resources.

property fingerprint

fingerprint?: pulumi.Input<string>;

The fingerprint of the public key.

property name

name?: pulumi.Input<string>;

A unique name for the keypair. Changing this creates a new keypair.

property privateKey

privateKey?: pulumi.Input<string>;

The generated private key when no public key is specified.

property publicKey

publicKey?: pulumi.Input<string>;

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.

property region

region?: pulumi.Input<string>;

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.

property valueSpecs

valueSpecs?: pulumi.Input<{[key: string]: any}>;

Map of additional options.

interface SecGroupArgs

The set of arguments for constructing a SecGroup resource.

property description

description: pulumi.Input<string>;

A description for the security group. Changing this updates the description of an existing security group.

property name

name?: pulumi.Input<string>;

A unique name for the security group. Changing this updates the name of an existing security group.

property region

region?: pulumi.Input<string>;

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.

property rules

rules?: pulumi.Input<pulumi.Input<{
    cidr: pulumi.Input<string>;
    fromGroupId: pulumi.Input<string>;
    fromPort: pulumi.Input<number>;
    id: pulumi.Input<string>;
    ipProtocol: pulumi.Input<string>;
    self: pulumi.Input<boolean>;
    toPort: pulumi.Input<number>;
}>[]>;

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.

interface SecGroupState

Input properties used for looking up and filtering SecGroup resources.

property description

description?: pulumi.Input<string>;

A description for the security group. Changing this updates the description of an existing security group.

property name

name?: pulumi.Input<string>;

A unique name for the security group. Changing this updates the name of an existing security group.

property region

region?: pulumi.Input<string>;

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.

property rules

rules?: pulumi.Input<pulumi.Input<{
    cidr: pulumi.Input<string>;
    fromGroupId: pulumi.Input<string>;
    fromPort: pulumi.Input<number>;
    id: pulumi.Input<string>;
    ipProtocol: pulumi.Input<string>;
    self: pulumi.Input<boolean>;
    toPort: pulumi.Input<number>;
}>[]>;

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.

interface ServerGroupArgs

The set of arguments for constructing a ServerGroup resource.

property name

name?: pulumi.Input<string>;

A unique name for the server group. Changing this creates a new server group.

property policies

policies?: pulumi.Input<pulumi.Input<string>[]>;

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.

property region

region?: pulumi.Input<string>;

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.

property valueSpecs

valueSpecs?: pulumi.Input<{[key: string]: any}>;

Map of additional options.

interface ServerGroupState

Input properties used for looking up and filtering ServerGroup resources.

property members

members?: pulumi.Input<pulumi.Input<string>[]>;

The instances that are part of this server group.

property name

name?: pulumi.Input<string>;

A unique name for the server group. Changing this creates a new server group.

property policies

policies?: pulumi.Input<pulumi.Input<string>[]>;

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.

property region

region?: pulumi.Input<string>;

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.

property valueSpecs

valueSpecs?: pulumi.Input<{[key: string]: any}>;

Map of additional options.

interface VolumeAttachArgs

The set of arguments for constructing a VolumeAttach resource.

property device

device?: pulumi.Input<string>;

The device of the volume attachment (ex: /dev/vdc). NOTE: Being able to specify a device is dependent upon the hypervisor in use. There is a chance that the device specified in Terraform will not be the same device the hypervisor chose. If this happens, Terraform will wish to update the device upon subsequent applying which will cause the volume to be detached and reattached indefinitely. Please use with caution.

property instanceId

instanceId: pulumi.Input<string>;

The ID of the Instance to attach the Volume to.

property multiattach

multiattach?: pulumi.Input<boolean>;

Enable attachment of multiattach-capable volumes.

property region

region?: pulumi.Input<string>;

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.

property volumeId

volumeId: pulumi.Input<string>;

The ID of the Volume to attach to an Instance.

interface VolumeAttachState

Input properties used for looking up and filtering VolumeAttach resources.

property device

device?: pulumi.Input<string>;

The device of the volume attachment (ex: /dev/vdc). NOTE: Being able to specify a device is dependent upon the hypervisor in use. There is a chance that the device specified in Terraform will not be the same device the hypervisor chose. If this happens, Terraform will wish to update the device upon subsequent applying which will cause the volume to be detached and reattached indefinitely. Please use with caution.

property instanceId

instanceId?: pulumi.Input<string>;

The ID of the Instance to attach the Volume to.

property multiattach

multiattach?: pulumi.Input<boolean>;

Enable attachment of multiattach-capable volumes.

property region

region?: pulumi.Input<string>;

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.

property volumeId

volumeId?: pulumi.Input<string>;

The ID of the Volume to attach to an Instance.