ComputeClusterVmGroup

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 clusterVmGroup = new VSphere.ComputeClusterVmGroup("clusterVmGroup", new VSphere.ComputeClusterVmGroupArgs
        {
            ComputeClusterId = cluster.Apply(cluster => cluster.Id),
            VirtualMachineIds = vm.Select(__item => __item.Id).ToList(),
        });
    }

}

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_group = vsphere.ComputeClusterVmGroup("clusterVmGroup",
    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 clusterVmGroup = new vsphere.ComputeClusterVmGroup("cluster_vm_group", {
    computeClusterId: cluster.id,
    virtualMachineIds: vm.map(v => v.id),
});