ComputeClusterVmAntiAffinityRule

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

This rule can be used to tell a set to virtual machines to run on different hosts within a cluster, useful for preventing single points of failure in application cluster scenarios. When configured, DRS will make a best effort to ensure that the virtual machines run on different hosts, or prevent any operation that would keep that from happening, depending on the value of the mandatory flag.

Keep in mind that this rule can only be used to tell VMs to run separately on non-specific hosts - specific hosts cannot be specified with this rule. For that, see the vsphere..ComputeClusterVmHostRule resource.
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 System.Collections.Generic;
using System.Linq;
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 network = dc.Apply(dc => Output.Create(VSphere.GetNetwork.InvokeAsync(new VSphere.GetNetworkArgs
        {
            DatacenterId = dc.Id,
            Name = "network1",
        })));
        var vm = new List<VSphere.VirtualMachine>();
        for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            vm.Add(new VSphere.VirtualMachine($"vm-{range.Value}", 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 clusterVmAntiAffinityRule = new VSphere.ComputeClusterVmAntiAffinityRule("clusterVmAntiAffinityRule", new VSphere.ComputeClusterVmAntiAffinityRuleArgs
        {
            ComputeClusterId = cluster.Apply(cluster => cluster.Id),
            VirtualMachineIds = vm.Select(__item => __item.Id).ToList(),
        });
    }

}

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")
network = vsphere.get_network(datacenter_id=dc.id,
    name="network1")
vm = []
for range in [{"value": i} for i in range(0, 2)]:
    vm.append(vsphere.VirtualMachine(f"vm-{range['value']}",
        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_anti_affinity_rule = vsphere.ComputeClusterVmAntiAffinityRule("clusterVmAntiAffinityRule",
    compute_cluster_id=cluster.id,
    virtual_machine_ids=[__item.id for __item in vm])

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 network = dc.apply(dc => vsphere.getNetwork({
    datacenterId: dc.id,
    name: "network1",
}, { async: true }));
const vm: vsphere.VirtualMachine[] = [];
for (let i = 0; i < 2; i++) {
    vm.push(new vsphere.VirtualMachine(`vm-${i}`, {
        datastoreId: datastore.id,
        disks: [{
            label: "disk0",
            size: 20,
        }],
        guestId: "other3xLinux64Guest",
        memory: 2048,
        networkInterfaces: [{
            networkId: network.id,
        }],
        numCpus: 2,
        resourcePoolId: cluster.resourcePoolId,
    }));
}
const clusterVmAntiAffinityRule = new vsphere.ComputeClusterVmAntiAffinityRule("cluster_vm_anti_affinity_rule", {
    computeClusterId: cluster.id,
    virtualMachineIds: vm.map(v => v.id),
});

Create a ComputeClusterVmAntiAffinityRule Resource

new ComputeClusterVmAntiAffinityRule(name: string, args: ComputeClusterVmAntiAffinityRuleArgs, opts?: CustomResourceOptions);

def ComputeClusterVmAntiAffinityRule(resource_name, opts=None, compute_cluster_id=None, enabled=None, mandatory=None, name=None, virtual_machine_ids=None, __props__=None);

func NewComputeClusterVmAntiAffinityRule(ctx *Context, name string, args ComputeClusterVmAntiAffinityRuleArgs, opts ...ResourceOption) (*ComputeClusterVmAntiAffinityRule, error)

public ComputeClusterVmAntiAffinityRule(string name, ComputeClusterVmAntiAffinityRuleArgs args, CustomResourceOptions? opts = null)

name string: The unique name of the resource.
args ComputeClusterVmAntiAffinityRuleArgs: 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 ComputeClusterVmAntiAffinityRuleArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

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