Function: Create a Distributed Virtual Portgroups

by Simon Sparks · 22 May 2021

To use this function add it to the class library file named PluginVCDistributedVirtualPortgroupService.ts

GitHub Repository: https://github.com/SimonSparksUK/Orchestrator

Filename: PluginVCDistributedVirtualPortgroupService.ts

Description: Orchestrator Function to Create a Distributed Virtual Portgroups

Function VcDistributedVirtualPortgroupCreate

public VcDistributedVirtualPortgroupCreate(objVcVmwareDistributedVirtualSwitch: VcVmwareDistributedVirtualSwitch): void {
    let arrUplinkPortName: string[] = [];
    arrUplinkPortName.push("dvUplink-A");
    arrUplinkPortName.push("dvUplink-B");

    let arrPortGroup: { strPortgroupName: string, intVLANNumber: number, arrPortGroupUplink: any[], strLoadBalancingMethod: string }[] = [];
    arrPortGroup.push({ strPortgroupName: "pgVLAN-10-Management", intVLANNumber: 10, strLoadBalancingMethod: "loadbalance_loadbased", arrPortGroupUplink: ["dvUplink-A", "dvUplink-B"] });
    arrPortGroup.push({ strPortgroupName: "pgVLAN-20-Provisioning", intVLANNumber: 20, strLoadBalancingMethod: "loadbalance_loadbased", arrPortGroupUplink: ["dvUplink-A", "dvUplink-B"] });
    arrPortGroup.push({ strPortgroupName: "pgVLAN-30-vMotion-A", intVLANNumber: 30, strLoadBalancingMethod: "loadbalance_loadbased", arrPortGroupUplink: ["dvUplink-A"] });
    arrPortGroup.push({ strPortgroupName: "pgVLAN-30-vMotion-B", intVLANNumber: 30, strLoadBalancingMethod: "loadbalance_loadbased", arrPortGroupUplink: ["dvUplink-B"] });

    let arrVcDistributedVirtualPortgroup: VcDistributedVirtualPortgroup[] = objVcVmwareDistributedVirtualSwitch.portgroup;

    arrVcDistributedVirtualPortgroup.forEach((objVcDistributedVirtualPortgroup: VcDistributedVirtualPortgroup): void => {

        let strVcDistributedVirtualPortgroupName: string = objVcDistributedVirtualPortgroup.name;

        this.objLogger.info("===== Port Group Name = " + strVcDistributedVirtualPortgroupName);

        this.objLogger.info("===== Re-Naming dvSwitch Uplink Port Group");

        if (strVcDistributedVirtualPortgroupName.search("dvSwitch-DVUplinks-") > -1) {

            let objVcTask: VcTask = objVcDistributedVirtualPortgroup.rename_Task("dvSwitch-vSphere-Services-Uplinks")

            this.WaitForVcTaskEnd(objVcTask, 1);
        }

    });

    let objVcBoolPolicyFALSE: VcBoolPolicy = new VcBoolPolicy();
    objVcBoolPolicyFALSE.inherited = false;
    objVcBoolPolicyFALSE.value = false;

    let objVcBoolPolicyTRUE: VcBoolPolicy = new VcBoolPolicy();
    objVcBoolPolicyTRUE.inherited = false;
    objVcBoolPolicyTRUE.value = true;

    let objVcLongPolicy: VcLongPolicy = new VcLongPolicy();
    objVcLongPolicy.inherited = true;

    let objVcBoolPolicyInherited: VcBoolPolicy = new VcBoolPolicy();
    objVcBoolPolicyInherited.inherited = true;

    let arrVcDVPortgroupConfigSpec: VcDVPortgroupConfigSpec[] = arrPortGroup.map((objPortGroup) => {

        let strPortGroupName: string = objPortGroup.strPortgroupName;

        let intPortGroupVLAN: number = objPortGroup.intVLANNumber;

        let arrPortGroupUplink: any[] = objPortGroup.arrPortGroupUplink;

        let strPortGroupTeamingPolicy: string = objPortGroup.strLoadBalancingMethod;

        let objVcVmwareDistributedVirtualSwitchVlanIdSpec: VcVmwareDistributedVirtualSwitchVlanIdSpec = new VcVmwareDistributedVirtualSwitchVlanIdSpec();
        objVcVmwareDistributedVirtualSwitchVlanIdSpec.inherited = false;
        objVcVmwareDistributedVirtualSwitchVlanIdSpec.vlanId = intPortGroupVLAN;

        let objVcDVSTrafficShapingPolicyIN: VcDVSTrafficShapingPolicy = new VcDVSTrafficShapingPolicy();
        objVcDVSTrafficShapingPolicyIN.inherited = false;
        objVcDVSTrafficShapingPolicyIN.enabled = objVcBoolPolicyFALSE;
        objVcDVSTrafficShapingPolicyIN.averageBandwidth = objVcLongPolicy;	// (ingressShapingAvg * 1000); // default value = 100000000 (bits per sec - so this value/1000 is what is shown as Kbits/sec in vCenter UI)
        objVcDVSTrafficShapingPolicyIN.peakBandwidth = objVcLongPolicy;	// (ingressShapingPeak * 1000); // default value same as averageBandwidth.value
        objVcDVSTrafficShapingPolicyIN.burstSize = objVcLongPolicy;	// (ingressShapingBurst * 1024); // default value = 104857600 (102400 Kbytes as shown in vCenter UI)

        let objVcDVSTrafficShapingPolicyOUT: VcDVSTrafficShapingPolicy = new VcDVSTrafficShapingPolicy();
        objVcDVSTrafficShapingPolicyOUT.inherited = false;
        objVcDVSTrafficShapingPolicyOUT.enabled = objVcBoolPolicyFALSE;
        objVcDVSTrafficShapingPolicyOUT.averageBandwidth = objVcLongPolicy;	// (egressShapingAvg * 1000); // default value = 100000000 (bits per sec - so this value/1000 is what is shown as Kbits/sec in vCenter UI)
        objVcDVSTrafficShapingPolicyOUT.peakBandwidth = objVcLongPolicy;	// (egressShapingPeak * 1000); // default value same as averageBandwidth.value
        objVcDVSTrafficShapingPolicyOUT.burstSize = objVcLongPolicy;	// (egressShapingBurst * 1024); // default value = 104857600 (102400 Kbytes as shown in vCenter UI)

        let objVcDVSFailureCriteria: VcDVSFailureCriteria = new VcDVSFailureCriteria();
        objVcDVSFailureCriteria.inherited = true;

        let objVcVMwareUplinkPortOrderPolicy: VcVMwareUplinkPortOrderPolicy = new VcVMwareUplinkPortOrderPolicy();
        objVcVMwareUplinkPortOrderPolicy.inherited = false;
        objVcVMwareUplinkPortOrderPolicy.activeUplinkPort = arrPortGroupUplink;
        objVcVMwareUplinkPortOrderPolicy.standbyUplinkPort = [];

        let objVcBoolPolicyRollingOrder: VcBoolPolicy = new VcBoolPolicy();
        objVcBoolPolicyRollingOrder.inherited = false;
        objVcBoolPolicyRollingOrder.value = false;

        let objVcBoolPolicyNotifySwitches: VcBoolPolicy = new VcBoolPolicy();
        objVcBoolPolicyNotifySwitches.inherited = false;
        objVcBoolPolicyNotifySwitches.value = true;

        let objVcStringPolicyPolicy: VcStringPolicy = new VcStringPolicy();
        objVcStringPolicyPolicy.inherited = false;
        objVcStringPolicyPolicy.value = strPortGroupTeamingPolicy;

        let objVcVmwareUplinkPortTeamingPolicy: VcVmwareUplinkPortTeamingPolicy = new VcVmwareUplinkPortTeamingPolicy();
        objVcVmwareUplinkPortTeamingPolicy.inherited = false;
        objVcVmwareUplinkPortTeamingPolicy.policy = objVcStringPolicyPolicy;
        objVcVmwareUplinkPortTeamingPolicy.notifySwitches = objVcBoolPolicyNotifySwitches;
        objVcVmwareUplinkPortTeamingPolicy.rollingOrder = objVcBoolPolicyRollingOrder;
        objVcVmwareUplinkPortTeamingPolicy.failureCriteria = objVcDVSFailureCriteria;
        objVcVmwareUplinkPortTeamingPolicy.uplinkPortOrder = objVcVMwareUplinkPortOrderPolicy;

        let objVcVMwareDVSPortgroupPolicy: VcVMwareDVSPortgroupPolicy = new VcVMwareDVSPortgroupPolicy();
        objVcVMwareDVSPortgroupPolicy.portConfigResetAtDisconnect = true;
        objVcVMwareDVSPortgroupPolicy.blockOverrideAllowed = true;
        objVcVMwareDVSPortgroupPolicy.shapingOverrideAllowed = false;
        objVcVMwareDVSPortgroupPolicy.vendorConfigOverrideAllowed = false;
        objVcVMwareDVSPortgroupPolicy.livePortMovingAllowed = false;
        objVcVMwareDVSPortgroupPolicy.vlanOverrideAllowed = false;
        objVcVMwareDVSPortgroupPolicy.uplinkTeamingOverrideAllowed = false;
        objVcVMwareDVSPortgroupPolicy.securityPolicyOverrideAllowed = false;

        let objVcDVSSecurityPolicy: VcDVSSecurityPolicy = new VcDVSSecurityPolicy();
        objVcDVSSecurityPolicy.inherited = true;
        objVcDVSSecurityPolicy.allowPromiscuous = objVcBoolPolicyInherited;
        objVcDVSSecurityPolicy.forgedTransmits = objVcBoolPolicyTRUE;
        objVcDVSSecurityPolicy.macChanges = objVcBoolPolicyTRUE;

        let objVcStringPolicyNetworkResourcePoolKey: VcStringPolicy = new VcStringPolicy();
        objVcStringPolicyNetworkResourcePoolKey.inherited = false;
        objVcStringPolicyNetworkResourcePoolKey.value = "-1";

        let objVcIntPolicyQosTag: VcIntPolicy = new VcIntPolicy();
        objVcIntPolicyQosTag.inherited = true;
        objVcIntPolicyQosTag.value = 0;

        let objVcVMwareDVSPortSetting: VcVMwareDVSPortSetting = new VcVMwareDVSPortSetting();
        objVcVMwareDVSPortSetting.vlan = objVcVmwareDistributedVirtualSwitchVlanIdSpec;
        objVcVMwareDVSPortSetting.blocked = objVcBoolPolicyFALSE;
        objVcVMwareDVSPortSetting.inShapingPolicy = objVcDVSTrafficShapingPolicyIN;
        objVcVMwareDVSPortSetting.outShapingPolicy = objVcDVSTrafficShapingPolicyOUT;
        objVcVMwareDVSPortSetting.ipfixEnabled = objVcBoolPolicyInherited;
        objVcVMwareDVSPortSetting.networkResourcePoolKey = objVcStringPolicyNetworkResourcePoolKey;
        objVcVMwareDVSPortSetting.qosTag = objVcIntPolicyQosTag;
        objVcVMwareDVSPortSetting.securityPolicy = objVcDVSSecurityPolicy;
        objVcVMwareDVSPortSetting.txUplink = objVcBoolPolicyInherited;
        objVcVMwareDVSPortSetting.uplinkTeamingPolicy = objVcVmwareUplinkPortTeamingPolicy;
        objVcVMwareDVSPortSetting.vmDirectPathGen2Allowed = objVcBoolPolicyInherited;

        let objVcDVPortgroupConfigSpec: VcDVPortgroupConfigSpec = new VcDVPortgroupConfigSpec();
        objVcDVPortgroupConfigSpec.name = strPortGroupName;
        objVcDVPortgroupConfigSpec.description = strPortGroupName;
        objVcDVPortgroupConfigSpec.numPorts = 16;
        objVcDVPortgroupConfigSpec.type = "earlyBinding";
        objVcDVPortgroupConfigSpec.autoExpand = true;
        objVcDVPortgroupConfigSpec.configVersion = "5.1.0";
        objVcDVPortgroupConfigSpec.policy = objVcVMwareDVSPortgroupPolicy;
        objVcDVPortgroupConfigSpec.portNameFormat = null;
        objVcDVPortgroupConfigSpec.defaultPortConfig = objVcVMwareDVSPortSetting;

        return objVcDVPortgroupConfigSpec;
    });


    let objVcTask: VcTask = objVcVmwareDistributedVirtualSwitch.addDVPortgroup_Task(arrVcDVPortgroupConfigSpec);

    this.WaitForVcTaskEnd(objVcTask, 1);
}

Discover more from Cloud Build Tools

Subscribe to get the latest posts sent to your email.

You may also like