ComputeClusterVmAffinityRule

The vsphere..ComputeClusterVmAffinityRule resource can be used to manage VM 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 together on a single host within a cluster. When configured, DRS will make a best effort to ensure that the virtual machines run on the same host, 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 together on a non-specific host - it can’t be used to pin VMs to a host. 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 clusterVmAffinityRule = new VSphere.ComputeClusterVmAffinityRule("clusterVmAffinityRule", new VSphere.ComputeClusterVmAffinityRuleArgs
        {
            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_affinity_rule = vsphere.ComputeClusterVmAffinityRule("clusterVmAffinityRule",
    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 clusterVmAffinityRule = new vsphere.ComputeClusterVmAffinityRule("cluster_vm_affinity_rule", {
    computeClusterId: cluster.id,
    virtualMachineIds: vm.map(v => v.id),
});

Create a ComputeClusterVmAffinityRule Resource

new ComputeClusterVmAffinityRule(name: string, args: ComputeClusterVmAffinityRuleArgs, opts?: CustomResourceOptions);

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

func NewComputeClusterVmAffinityRule(ctx *Context, name string, args ComputeClusterVmAffinityRuleArgs, opts ...ResourceOption) (*ComputeClusterVmAffinityRule, error)

public ComputeClusterVmAffinityRule(string name, ComputeClusterVmAffinityRuleArgs args, CustomResourceOptions? opts = null)

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

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