ComputeClusterVmHostRule

The vsphere..ComputeClusterVmHostRule resource can be used to manage VM-to-host rules in a cluster, either created by the vsphere..ComputeCluster resource or looked up by the vsphere..ComputeCluster data source.

This resource can create both affinity rules, where virtual machines run on specified hosts, or anti-affinity rules, where virtual machines run on hosts outside of the ones specified in the rule. Virtual machines and hosts are supplied via groups, which can be managed via the vsphere..ComputeClusterVmGroup and vsphere..ComputeClusterHostGroup resources.

NOTE: This resource requires vCenter and is not available on direct ESXi connections.
NOTE: vSphere DRS requires a vSphere Enterprise Plus license.

Example Usage

using Pulumi;
using VSphere = Pulumi.VSphere;

class MyStack : Stack
{
    public MyStack()
    {
        var dc = Output.Create(VSphere.GetDatacenter.InvokeAsync(new VSphere.GetDatacenterArgs
        {
            Name = "dc1",
        }));
        var datastore = dc.Apply(dc => Output.Create(VSphere.GetDatastore.InvokeAsync(new VSphere.GetDatastoreArgs
        {
            DatacenterId = dc.Id,
            Name = "datastore1",
        })));
        var cluster = dc.Apply(dc => Output.Create(VSphere.GetComputeCluster.InvokeAsync(new VSphere.GetComputeClusterArgs
        {
            DatacenterId = dc.Id,
            Name = "cluster1",
        })));
        var host = dc.Apply(dc => Output.Create(VSphere.GetHost.InvokeAsync(new VSphere.GetHostArgs
        {
            DatacenterId = dc.Id,
            Name = "esxi1",
        })));
        var network = dc.Apply(dc => Output.Create(VSphere.GetNetwork.InvokeAsync(new VSphere.GetNetworkArgs
        {
            DatacenterId = dc.Id,
            Name = "network1",
        })));
        var vm = new VSphere.VirtualMachine("vm", new VSphere.VirtualMachineArgs
        {
            DatastoreId = datastore.Apply(datastore => datastore.Id),
            Disks = 
            {
                new VSphere.Inputs.VirtualMachineDiskArgs
                {
                    Label = "disk0",
                    Size = 20,
                },
            },
            GuestId = "other3xLinux64Guest",
            Memory = 2048,
            NetworkInterfaces = 
            {
                new VSphere.Inputs.VirtualMachineNetworkInterfaceArgs
                {
                    NetworkId = network.Apply(network => network.Id),
                },
            },
            NumCpus = 2,
            ResourcePoolId = cluster.Apply(cluster => cluster.ResourcePoolId),
        });
        var clusterVmGroup = new VSphere.ComputeClusterVmGroup("clusterVmGroup", new VSphere.ComputeClusterVmGroupArgs
        {
            ComputeClusterId = cluster.Apply(cluster => cluster.Id),
            VirtualMachineIds = 
            {
                vm.Id,
            },
        });
        var clusterHostGroup = new VSphere.ComputeClusterHostGroup("clusterHostGroup", new VSphere.ComputeClusterHostGroupArgs
        {
            ComputeClusterId = cluster.Apply(cluster => cluster.Id),
            HostSystemIds = 
            {
                host.Apply(host => host.Id),
            },
        });
        var clusterVmHostRule = new VSphere.ComputeClusterVmHostRule("clusterVmHostRule", new VSphere.ComputeClusterVmHostRuleArgs
        {
            AffinityHostGroupName = clusterHostGroup.Name,
            ComputeClusterId = cluster.Apply(cluster => cluster.Id),
            VmGroupName = clusterVmGroup.Name,
        });
    }

}

Coming soon!

import pulumi
import pulumi_vsphere as vsphere

dc = vsphere.get_datacenter(name="dc1")
datastore = vsphere.get_datastore(datacenter_id=dc.id,
    name="datastore1")
cluster = vsphere.get_compute_cluster(datacenter_id=dc.id,
    name="cluster1")
host = vsphere.get_host(datacenter_id=dc.id,
    name="esxi1")
network = vsphere.get_network(datacenter_id=dc.id,
    name="network1")
vm = vsphere.VirtualMachine("vm",
    datastore_id=datastore.id,
    disks=[{
        "label": "disk0",
        "size": 20,
    }],
    guest_id="other3xLinux64Guest",
    memory=2048,
    network_interfaces=[{
        "networkId": network.id,
    }],
    num_cpus=2,
    resource_pool_id=cluster.resource_pool_id)
cluster_vm_group = vsphere.ComputeClusterVmGroup("clusterVmGroup",
    compute_cluster_id=cluster.id,
    virtual_machine_ids=[vm.id])
cluster_host_group = vsphere.ComputeClusterHostGroup("clusterHostGroup",
    compute_cluster_id=cluster.id,
    host_system_ids=[host.id])
cluster_vm_host_rule = vsphere.ComputeClusterVmHostRule("clusterVmHostRule",
    affinity_host_group_name=cluster_host_group.name,
    compute_cluster_id=cluster.id,
    vm_group_name=cluster_vm_group.name)

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

const dc = pulumi.output(vsphere.getDatacenter({
    name: "dc1",
}, { async: true }));
const datastore = dc.apply(dc => vsphere.getDatastore({
    datacenterId: dc.id,
    name: "datastore1",
}, { async: true }));
const cluster = dc.apply(dc => vsphere.getComputeCluster({
    datacenterId: dc.id,
    name: "cluster1",
}, { async: true }));
const host = dc.apply(dc => vsphere.getHost({
    datacenterId: dc.id,
    name: "esxi1",
}, { async: true }));
const network = dc.apply(dc => vsphere.getNetwork({
    datacenterId: dc.id,
    name: "network1",
}, { async: true }));
const vm = new vsphere.VirtualMachine("vm", {
    datastoreId: datastore.id,
    disks: [{
        label: "disk0",
        size: 20,
    }],
    guestId: "other3xLinux64Guest",
    memory: 2048,
    networkInterfaces: [{
        networkId: network.id,
    }],
    numCpus: 2,
    resourcePoolId: cluster.resourcePoolId,
});
const clusterVmGroup = new vsphere.ComputeClusterVmGroup("cluster_vm_group", {
    computeClusterId: cluster.id,
    virtualMachineIds: [vm.id],
});
const clusterHostGroup = new vsphere.ComputeClusterHostGroup("cluster_host_group", {
    computeClusterId: cluster.id,
    hostSystemIds: [host.id],
});
const clusterVmHostRule = new vsphere.ComputeClusterVmHostRule("cluster_vm_host_rule", {
    affinityHostGroupName: clusterHostGroup.name,
    computeClusterId: cluster.id,
    vmGroupName: clusterVmGroup.name,
});

Create a ComputeClusterVmHostRule Resource

new ComputeClusterVmHostRule(name: string, args: ComputeClusterVmHostRuleArgs, opts?: CustomResourceOptions);

def ComputeClusterVmHostRule(resource_name, opts=None, affinity_host_group_name=None, anti_affinity_host_group_name=None, compute_cluster_id=None, enabled=None, mandatory=None, name=None, vm_group_name=None, __props__=None);

func NewComputeClusterVmHostRule(ctx *Context, name string, args ComputeClusterVmHostRuleArgs, opts ...ResourceOption) (*ComputeClusterVmHostRule, error)

public ComputeClusterVmHostRule(string name, ComputeClusterVmHostRuleArgs args, CustomResourceOptions? opts = null)

name string: The unique name of the resource.
args ComputeClusterVmHostRuleArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
opts ResourceOptions: A bag of options that control this resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args ComputeClusterVmHostRuleArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args ComputeClusterVmHostRuleArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.