DatastoreClusterVmAntiAffinityRule

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

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

NOTE: This resource requires vCenter and is not available on direct ESXi connections.
NOTE: Storage 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 datastoreCluster = dc.Apply(dc => Output.Create(VSphere.GetDatastoreCluster.InvokeAsync(new VSphere.GetDatastoreClusterArgs
        {
            DatacenterId = dc.Id,
            Name = "datastore-cluster1",
        })));
        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
            {
                DatastoreClusterId = datastoreCluster.Apply(datastoreCluster => datastoreCluster.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.DatastoreClusterVmAntiAffinityRule("clusterVmAntiAffinityRule", new VSphere.DatastoreClusterVmAntiAffinityRuleArgs
        {
            DatastoreClusterId = datastoreCluster.Apply(datastoreCluster => datastoreCluster.Id),
            VirtualMachineIds = vm.Select(__item => __item.Id).ToList(),
        });
    }

}

Coming soon!

import pulumi
import pulumi_vsphere as vsphere

dc = vsphere.get_datacenter(name="dc1")
datastore_cluster = vsphere.get_datastore_cluster(datacenter_id=dc.id,
    name="datastore-cluster1")
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_cluster_id=datastore_cluster.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.DatastoreClusterVmAntiAffinityRule("clusterVmAntiAffinityRule",
    datastore_cluster_id=datastore_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 datastoreCluster = dc.apply(dc => vsphere.getDatastoreCluster({
    datacenterId: dc.id,
    name: "datastore-cluster1",
}, { 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}`, {
        datastoreClusterId: datastoreCluster.id,
        disks: [{
            label: "disk0",
            size: 20,
        }],
        guestId: "other3xLinux64Guest",
        memory: 2048,
        networkInterfaces: [{
            networkId: network.id,
        }],
        numCpus: 2,
        resourcePoolId: cluster.resourcePoolId,
    }));
}
const clusterVmAntiAffinityRule = new vsphere.DatastoreClusterVmAntiAffinityRule("cluster_vm_anti_affinity_rule", {
    datastoreClusterId: datastoreCluster.id,
    virtualMachineIds: vm.map(v => v.id),
});

Create a DatastoreClusterVmAntiAffinityRule Resource

new DatastoreClusterVmAntiAffinityRule(name: string, args: DatastoreClusterVmAntiAffinityRuleArgs, opts?: CustomResourceOptions);

def DatastoreClusterVmAntiAffinityRule(resource_name, opts=None, datastore_cluster_id=None, enabled=None, mandatory=None, name=None, virtual_machine_ids=None, __props__=None);

func NewDatastoreClusterVmAntiAffinityRule(ctx *Context, name string, args DatastoreClusterVmAntiAffinityRuleArgs, opts ...ResourceOption) (*DatastoreClusterVmAntiAffinityRule, error)

public DatastoreClusterVmAntiAffinityRule(string name, DatastoreClusterVmAntiAffinityRuleArgs args, CustomResourceOptions? opts = null)

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

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