@microsoft/terraform-cdk-constructs 0.0.3-pre.10

package/lib/azure-virtualmachinescaleset/lib/cluster.js

@@ -0,0 +1,264 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsCluster = exports.LinuxCluster = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const linux_virtual_machine_scale_set_1 = require("@cdktf/provider-azurerm/lib/linux-virtual-machine-scale-set");
+const virtual_machine_scale_set_extension_1 = require("@cdktf/provider-azurerm/lib/virtual-machine-scale-set-extension");
+const windows_virtual_machine_scale_set_1 = require("@cdktf/provider-azurerm/lib/windows-virtual-machine-scale-set");
+const azure_virtualmachine_1 = require("../../azure-virtualmachine");
+const network_1 = require("../../azure-virtualnetwork/lib/network");
+const lib_1 = require("../../core-azure/lib");
+class LinuxCluster extends lib_1.AzureResource {
+    /**
+     * Represents a Linux Virtual Machine Scale Set (VMSS) within Microsoft Azure.
+     *
+     * This class is designed to provision and manage a scale set of Linux virtual machines, providing capabilities such as
+     * auto-scaling, high availability, and simplified management. It supports detailed configurations like VM size, operating
+     * system image, network settings, and administrative credentials. Additional functionalities include custom data scripts,
+     * SSH configurations, and optional features like managed identity and boot diagnostics.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) application.
+     * @param id - The unique identifier for this instance of the Linux cluster, used within the scope for reference.
+     * @param props - Configuration properties for the Linux VM Scale Set, derived from the LinuxClusterProps interface. These include:
+     *                - `location`: The geographic location where the scale set will be hosted (e.g., "eastus").
+     *                - `name`: The name of the scale set, which must be unique within the resource group.
+     *                - `resourceGroup`: The ResourceGroup within which the scale set will be created.
+     *                - `sku`: The size specification of the VMs (e.g., "Standard_B2s").
+     *                - `adminUsername`: The administrator username for the VMs.
+     *                - `adminPassword`: The administrator password for the VMs.
+     *                - `adminSshKey`: SSH keys for secure access to the VMs.
+     *                - `zones`: The availability zones for deploying the VMs.
+     *                - `identity`: Managed identity settings for accessing other Azure services.
+     *                - `sourceImageReference`: A reference to the specific Linux image to be used for the VMs.
+     *                - `sourceImageId`: The identifier for a custom image to use for the VMs.
+     *                - `tags`: Key-value pairs for resource tagging.
+     *                - `osDisk`: Configuration for the VMs' operating system disks.
+     *                - `subnet`: Specifies the subnet within which the VMs will be placed.
+     *                - `publicIPAddress`: Method used to allocate public IP addresses to the VMs.
+     *                - `customData`: Scripts or commands passed to the VMs at startup.
+     *                - `instances`: The number of VM instances in the scale set.
+     *                - `upgradePolicyMode`: The upgrade policy mode for the VMSS.
+     *                - `overprovision`: Specifies if the VMSS should be overprovisioned to maintain capacity during updates.
+     *                - `scaleInPolicy`: The scale-in policy for the VMSS.
+     *                - `bootDiagnosticsStorageURI`: URI for storage where VMSS boot diagnostics are collected.
+     *                - `enableSshAzureADLogin`: Option to enable Azure AD login for SSH on the VMs.
+     *
+     * Example usage:
+     * ```typescript
+     * const linuxCluster = new LinuxCluster(this, 'MyLinuxCluster', {
+     *   resourceGroup: myResourceGroup,
+     *   name: 'myCluster',
+     *   sku: 'Standard_DS1_v2',
+     *   adminUsername: 'adminuser',
+     *   adminSshKey: [{ publicKey: 'ssh-rsa AAAAB...' }],
+     *   sourceImageReference: { publisher: 'Canonical', offer: 'UbuntuServer', sku: '18.04-LTS', version: 'latest' },
+     *   osDisk: { caching: 'ReadWrite', storageAccountType: 'Standard_LRS' },
+     *   subnet: mySubnet,
+     *   instances: 3,
+     *   tags: { environment: 'production' }
+     * });
+     * ```
+     * This class initializes a Linux VM Scale Set with the specified configurations, handling details like VM creation,
+     * scaling policies, network setup, OS installation, and security settings, providing a robust and scalable infrastructure
+     * for hosting cloud-based Linux applications.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.resourceGroup = props.resourceGroup;
+        const pathName = this.node.path.split("/")[0];
+        const defaults = {
+            name: props.name || pathName,
+            adminUsername: props.adminUsername || `admin${pathName}`,
+            location: props.location || "eastus",
+            sku: props.sku || "Standard_B2s",
+            instances: props.instances || 1,
+            osDisk: props.osDisk || {
+                caching: "ReadWrite",
+                storageAccountType: "Standard_LRS",
+            },
+            sourceImageReference: props.sourceImageReference || azure_virtualmachine_1.LinuxImageReferences.ubuntuServer2204LTS,
+            subnet: props.subnet ||
+                new network_1.Network(this, "vnet", {
+                    resourceGroup: props.resourceGroup,
+                }).subnets.default,
+        };
+        const azurermLinuxVirtualMachineScaleSet = new linux_virtual_machine_scale_set_1.LinuxVirtualMachineScaleSet(this, "vmss", {
+            ...defaults,
+            resourceGroupName: props.resourceGroup.name,
+            adminPassword: props.adminPassword,
+            disablePasswordAuthentication: props.adminPassword ? false : true,
+            tags: props.tags,
+            networkInterface: [
+                {
+                    name: `nic-${defaults.name}`,
+                    primary: true,
+                    ipConfiguration: [
+                        {
+                            name: "internal",
+                            subnetId: defaults.subnet.id,
+                            primary: true,
+                            publicIpAddress: props.publicIPAddress,
+                        },
+                    ],
+                },
+            ],
+            osDisk: {
+                ...defaults.osDisk,
+            },
+            sourceImageId: props.sourceImageId,
+            customData: props.customData
+                ? Buffer.from(props.customData).toString("base64")
+                : undefined,
+            userData: props.userData
+                ? Buffer.from(props.userData).toString("base64")
+                : undefined,
+            adminSshKey: props.adminSshKey,
+            identity: props.identity,
+        });
+        this.id = azurermLinuxVirtualMachineScaleSet.id;
+        this.name = azurermLinuxVirtualMachineScaleSet.name;
+        this.fqn = azurermLinuxVirtualMachineScaleSet.fqn;
+        // Enable SSH Azure AD Login if specified
+        if (props.enableSshAzureADLogin) {
+            new virtual_machine_scale_set_extension_1.VirtualMachineScaleSetExtensionA(this, "AADSSHlogin", {
+                name: "AADSSHLoginForLinux",
+                virtualMachineScaleSetId: this.id,
+                publisher: "Microsoft.Azure.ActiveDirectory",
+                type: "AADSSHLoginForLinux",
+                typeHandlerVersion: "1.0",
+            });
+        }
+    }
+}
+exports.LinuxCluster = LinuxCluster;
+_a = JSII_RTTI_SYMBOL_1;
+LinuxCluster[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_virtualmachinescaleset.LinuxCluster", version: "0.0.3-pre.10" };
+class WindowsCluster extends lib_1.AzureResource {
+    /**
+     * Represents a Windows Virtual Machine Scale Set (VMSS) within Microsoft Azure.
+     *
+     * This class provides a way to deploy and manage a scale set of Windows virtual machines, allowing for configurations such as
+     * auto-scaling, high availability, and simplified patch management. It supports detailed specifications including
+     * VM size, the operating system image, network settings, and administrative credentials. Additional capabilities include
+     * custom data scripts, automatic OS updates, and optional features like managed identity and boot diagnostics.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) application.
+     * @param id - The unique identifier for this instance of the Windows cluster, used within the scope for reference.
+     * @param props - Configuration properties for the Windows VM Scale Set, derived from the WindowsClusterProps interface. These include:
+     *                - `location`: The geographic location where the scale set will be hosted (e.g., "eastus").
+     *                - `name`: The name of the scale set, which must be unique within the resource group.
+     *                - `resourceGroup`: The ResourceGroup within which the scale set will be created.
+     *                - `sku`: The size specification of the VMs (e.g., "Standard_B2s").
+     *                - `adminUsername`: The administrator username for the VMs.
+     *                - `adminPassword`: The administrator password for the VMs.
+     *                - `zones`: The availability zones for deploying the VMs.
+     *                - `instances`: The number of VM instances in the scale set.
+     *                - `sourceImageReference`: A reference to the specific Windows image to be used for the VMs.
+     *                - `sourceImageId`: The identifier for a custom image to use for the VMs.
+     *                - `tags`: Key-value pairs for resource tagging.
+     *                - `osDisk`: Configuration for the VMs' operating system disks.
+     *                - `subnet`: Specifies the subnet within which the VMs will be placed.
+     *                - `publicIPAddress`: Method used to allocate public IP addresses to the VMs.
+     *                - `customData`: Scripts or commands passed to the VMs at startup.
+     *                - `upgradePolicyMode`: The upgrade policy mode for the VMSS.
+     *                - `overprovision`: Specifies if the VMSS should be overprovisioned to maintain capacity during updates.
+     *                - `scaleInPolicy`: The scale-in policy for the VMSS.
+     *                - `bootDiagnosticsStorageURI`: URI for storage where VMSS boot diagnostics are collected.
+     *                - `enableSshAzureADLogin`: Option to enable Azure AD login for SSH on the VMs.
+     *
+     * Example usage:
+     * ```typescript
+     * const windowsCluster = new WindowsCluster(this, 'MyWindowsCluster', {
+     *   resourceGroup: myResourceGroup,
+     *   name: 'myCluster',
+     *   sku: 'Standard_DS1_v2',
+     *   adminUsername: 'adminuser',
+     *   adminPassword: 'securepassword123',
+     *   sourceImageReference: { publisher: 'MicrosoftWindowsServer', offer: 'WindowsServer', sku: '2019-Datacenter', version: 'latest' },
+     *   osDisk: { caching: 'ReadWrite', storageAccountType: 'Standard_LRS' },
+     *   subnet: mySubnet,
+     *   instances: 3,
+     *   tags: { environment: 'production' }
+     * });
+     * ```
+     * This class initializes a Windows VM Scale Set with the specified configurations, handling details like VM creation,
+     * scaling policies, network setup, OS installation, and security settings, providing a robust and scalable infrastructure
+     * for hosting cloud-based Windows applications.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.resourceGroup = props.resourceGroup;
+        const pathName = this.node.path.split("/")[0];
+        // Default configurations for the virtual machine.
+        const defaults = {
+            name: props.name || this.node.path.split("/")[0],
+            adminUsername: props.adminUsername || `admin${pathName}`,
+            location: props.location || "eastus",
+            sku: props.sku || "Standard_B2s",
+            instances: props.instances || 1,
+            osDisk: props.osDisk || {
+                caching: "ReadWrite",
+                storageAccountType: "Standard_LRS",
+            },
+            sourceImageReference: props.sourceImageReference ||
+                azure_virtualmachine_1.WindowsImageReferences.windowsServer2022DatacenterCore,
+            subnet: props.subnet ||
+                new network_1.Network(this, "vnet", {
+                    resourceGroup: props.resourceGroup,
+                }).subnets.default,
+        };
+        // Base64 encode custom data if provided.
+        const customData = props.customData || props.boostrapCustomData;
+        const base64CustomData = customData
+            ? Buffer.from(customData).toString("base64")
+            : undefined;
+        // Create the Windows Virtual Machine.
+        const azurermWindowsVirtualMachine = new windows_virtual_machine_scale_set_1.WindowsVirtualMachineScaleSet(this, "vmss", {
+            ...defaults,
+            resourceGroupName: props.resourceGroup.name,
+            adminUsername: props.adminUsername,
+            adminPassword: props.adminPassword,
+            tags: props.tags,
+            networkInterface: [
+                {
+                    name: `nic-${defaults.name}`,
+                    primary: true,
+                    ipConfiguration: [
+                        {
+                            name: "internal",
+                            subnetId: defaults.subnet.id,
+                            primary: true,
+                            publicIpAddress: props.publicIPAddress,
+                        },
+                    ],
+                },
+            ],
+            osDisk: {
+                ...defaults.osDisk,
+            },
+            sourceImageId: props.sourceImageId,
+            customData: base64CustomData,
+            bootDiagnostics: { storageAccountUri: props.bootDiagnosticsStorageURI },
+        });
+        this.id = azurermWindowsVirtualMachine.id;
+        this.name = azurermWindowsVirtualMachine.name;
+        // Bootstrap VM with custom script extension if bootstrap custom data is provided.
+        if (props.boostrapCustomData) {
+            new virtual_machine_scale_set_extension_1.VirtualMachineScaleSetExtensionA(this, "script-ext", {
+                name: `${this.name}-script-ext`,
+                virtualMachineScaleSetId: this.id,
+                publisher: "Microsoft.Compute",
+                type: "CustomScriptExtension",
+                typeHandlerVersion: "1.10",
+                protectedSettings: '{"commandToExecute": "rename  C:\\\\AzureData\\\\CustomData.bin  postdeploy.ps1 & powershell -ExecutionPolicy Unrestricted -File C:\\\\AzureData\\\\postdeploy.ps1"}',
+            });
+        }
+    }
+}
+exports.WindowsCluster = WindowsCluster;
+_b = JSII_RTTI_SYMBOL_1;
+WindowsCluster[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_virtualmachinescaleset.WindowsCluster", version: "0.0.3-pre.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../../src/azure-virtualmachinescaleset/lib/cluster.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  LinuxVirtualMachineSourceImageReference,\n  LinuxVirtualMachineOsDisk,\n  LinuxVirtualMachineAdminSshKey,\n  LinuxVirtualMachineIdentity,\n} from \"@cdktf/provider-azurerm/lib/linux-virtual-machine\";\nimport {\n  LinuxVirtualMachineScaleSet,\n  LinuxVirtualMachineScaleSetNetworkInterfaceIpConfigurationPublicIpAddress,\n} from \"@cdktf/provider-azurerm/lib/linux-virtual-machine-scale-set\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Subnet } from \"@cdktf/provider-azurerm/lib/subnet\";\nimport { VirtualMachineScaleSetExtensionA } from \"@cdktf/provider-azurerm/lib/virtual-machine-scale-set-extension\";\nimport {\n  WindowsVirtualMachineOsDisk,\n  WindowsVirtualMachineSourceImageReference,\n} from \"@cdktf/provider-azurerm/lib/windows-virtual-machine\";\nimport {\n  WindowsVirtualMachineScaleSet,\n  WindowsVirtualMachineScaleSetNetworkInterfaceIpConfigurationPublicIpAddress,\n} from \"@cdktf/provider-azurerm/lib/windows-virtual-machine-scale-set\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  WindowsImageReferences,\n  LinuxImageReferences,\n} from \"../../azure-virtualmachine\";\nimport { Network } from \"../../azure-virtualnetwork/lib/network\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\nexport interface LinuxClusterProps {\n  /**\n   * The Azure location where the virtual machine scale set should be created.\n   * @default \"eastus\"\n   */\n  readonly location?: string;\n\n  /**\n   * The name of the virtual machine scale set.\n   * @default - Uses the name derived from the construct path.\n   */\n  readonly name?: string;\n\n  /**\n   * The admin username for the virtual machine.\n   */\n  readonly adminUsername?: string;\n\n  /**\n   * The admin password for the virtual machine.\n   */\n  readonly adminPassword?: string;\n\n  /**\n   * The name of the resource group in which the virtual machine scale set will be created.\n   */\n  readonly resourceGroup: ResourceGroup;\n\n  /**\n   * The size of the virtual machines in the scale set.\n   * @default \"Standard_B2s\"\n   */\n  readonly sku?: string;\n\n  /**\n   * Custom data to pass to the virtual machines upon creation.\n   */\n  readonly userData?: string;\n\n  /**\n   * An array of SSH keys for the admin user.\n   */\n  readonly adminSshKey?: LinuxVirtualMachineAdminSshKey[] | cdktf.IResolvable;\n\n  /**\n   * The availability zone(s) in which the VMs should be placed.\n   */\n  readonly zones?: string[];\n\n  /**\n   * Managed identity settings for the VMs.\n   */\n  readonly identity?: LinuxVirtualMachineIdentity;\n\n  /**\n   * The source image reference for the virtual machines.\n   * @default - Uses a default Ubuntu image.\n   */\n  readonly sourceImageReference?: LinuxVirtualMachineSourceImageReference;\n\n  /**\n   * The ID of the source image for the virtual machines.\n   */\n  readonly sourceImageId?: string;\n\n  /**\n   * Tags to apply to the virtual machine scale set.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * The OS disk configuration for the virtual machines.\n   * @default - Uses a disk with caching set to \"ReadWrite\" and storage account type \"Standard_LRS\".\n   */\n  readonly osDisk?: LinuxVirtualMachineOsDisk;\n\n  /**\n   * The subnet in which the virtual machines will be placed.\n   */\n  readonly subnet?: Subnet;\n\n  /**\n   * The allocation method for the public IP.\n   */\n  readonly publicIPAddress?: LinuxVirtualMachineScaleSetNetworkInterfaceIpConfigurationPublicIpAddress[];\n\n  /**\n   * Custom data to pass to the virtual machines upon creation.\n   */\n  readonly customData?: string;\n\n  /**\n   * The number of VM instances in the scale set.\n   * @default 2\n   */\n  readonly instances?: number;\n\n  /**\n   * Specifies the scale set's upgrade policy settings.\n   */\n  readonly upgradePolicyMode?: string;\n\n  /**\n   * Specifies if the VMSS should be overprovisioned.\n   * @default true\n   */\n  readonly overprovision?: boolean;\n\n  /**\n   * Specifies the scale-in policy for the VMSS.\n   */\n  readonly scaleInPolicy?: string;\n\n  /**\n   * Boot diagnostics settings for the VMSS.\n   */\n  readonly bootDiagnosticsStorageURI?: string;\n\n  /**\n   * Enable SSH Azure AD Login, required managed identity to be set.\n   * @default false\n   */\n  readonly enableSshAzureADLogin?: boolean;\n}\n\nexport class LinuxCluster extends AzureResource {\n  public readonly props: LinuxClusterProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  public readonly name: string;\n  public readonly fqn: string;\n\n  /**\n   * Represents a Linux Virtual Machine Scale Set (VMSS) within Microsoft Azure.\n   *\n   * This class is designed to provision and manage a scale set of Linux virtual machines, providing capabilities such as\n   * auto-scaling, high availability, and simplified management. It supports detailed configurations like VM size, operating\n   * system image, network settings, and administrative credentials. Additional functionalities include custom data scripts,\n   * SSH configurations, and optional features like managed identity and boot diagnostics.\n   *\n   * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) application.\n   * @param id - The unique identifier for this instance of the Linux cluster, used within the scope for reference.\n   * @param props - Configuration properties for the Linux VM Scale Set, derived from the LinuxClusterProps interface. These include:\n   *                - `location`: The geographic location where the scale set will be hosted (e.g., \"eastus\").\n   *                - `name`: The name of the scale set, which must be unique within the resource group.\n   *                - `resourceGroup`: The ResourceGroup within which the scale set will be created.\n   *                - `sku`: The size specification of the VMs (e.g., \"Standard_B2s\").\n   *                - `adminUsername`: The administrator username for the VMs.\n   *                - `adminPassword`: The administrator password for the VMs.\n   *                - `adminSshKey`: SSH keys for secure access to the VMs.\n   *                - `zones`: The availability zones for deploying the VMs.\n   *                - `identity`: Managed identity settings for accessing other Azure services.\n   *                - `sourceImageReference`: A reference to the specific Linux image to be used for the VMs.\n   *                - `sourceImageId`: The identifier for a custom image to use for the VMs.\n   *                - `tags`: Key-value pairs for resource tagging.\n   *                - `osDisk`: Configuration for the VMs' operating system disks.\n   *                - `subnet`: Specifies the subnet within which the VMs will be placed.\n   *                - `publicIPAddress`: Method used to allocate public IP addresses to the VMs.\n   *                - `customData`: Scripts or commands passed to the VMs at startup.\n   *                - `instances`: The number of VM instances in the scale set.\n   *                - `upgradePolicyMode`: The upgrade policy mode for the VMSS.\n   *                - `overprovision`: Specifies if the VMSS should be overprovisioned to maintain capacity during updates.\n   *                - `scaleInPolicy`: The scale-in policy for the VMSS.\n   *                - `bootDiagnosticsStorageURI`: URI for storage where VMSS boot diagnostics are collected.\n   *                - `enableSshAzureADLogin`: Option to enable Azure AD login for SSH on the VMs.\n   *\n   * Example usage:\n   * ```typescript\n   * const linuxCluster = new LinuxCluster(this, 'MyLinuxCluster', {\n   *   resourceGroup: myResourceGroup,\n   *   name: 'myCluster',\n   *   sku: 'Standard_DS1_v2',\n   *   adminUsername: 'adminuser',\n   *   adminSshKey: [{ publicKey: 'ssh-rsa AAAAB...' }],\n   *   sourceImageReference: { publisher: 'Canonical', offer: 'UbuntuServer', sku: '18.04-LTS', version: 'latest' },\n   *   osDisk: { caching: 'ReadWrite', storageAccountType: 'Standard_LRS' },\n   *   subnet: mySubnet,\n   *   instances: 3,\n   *   tags: { environment: 'production' }\n   * });\n   * ```\n   * This class initializes a Linux VM Scale Set with the specified configurations, handling details like VM creation,\n   * scaling policies, network setup, OS installation, and security settings, providing a robust and scalable infrastructure\n   * for hosting cloud-based Linux applications.\n   */\n  constructor(scope: Construct, id: string, props: LinuxClusterProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    const pathName = this.node.path.split(\"/\")[0];\n\n    const defaults = {\n      name: props.name || pathName,\n      adminUsername: props.adminUsername || `admin${pathName}`,\n      location: props.location || \"eastus\",\n      sku: props.sku || \"Standard_B2s\",\n      instances: props.instances || 1,\n      osDisk: props.osDisk || {\n        caching: \"ReadWrite\",\n        storageAccountType: \"Standard_LRS\",\n      },\n      sourceImageReference:\n        props.sourceImageReference || LinuxImageReferences.ubuntuServer2204LTS,\n      subnet:\n        props.subnet ||\n        new Network(this, \"vnet\", {\n          resourceGroup: props.resourceGroup,\n        }).subnets.default,\n    };\n\n    const azurermLinuxVirtualMachineScaleSet = new LinuxVirtualMachineScaleSet(\n      this,\n      \"vmss\",\n      {\n        ...defaults,\n        resourceGroupName: props.resourceGroup.name,\n        adminPassword: props.adminPassword,\n        disablePasswordAuthentication: props.adminPassword ? false : true,\n        tags: props.tags,\n        networkInterface: [\n          {\n            name: `nic-${defaults.name}`,\n            primary: true,\n            ipConfiguration: [\n              {\n                name: \"internal\",\n                subnetId: defaults.subnet.id,\n                primary: true,\n                publicIpAddress: props.publicIPAddress,\n              },\n            ],\n          },\n        ],\n        osDisk: {\n          ...defaults.osDisk,\n        },\n        sourceImageId: props.sourceImageId,\n        customData: props.customData\n          ? Buffer.from(props.customData).toString(\"base64\")\n          : undefined,\n        userData: props.userData\n          ? Buffer.from(props.userData).toString(\"base64\")\n          : undefined,\n        adminSshKey: props.adminSshKey,\n        identity: props.identity,\n      },\n    );\n\n    this.id = azurermLinuxVirtualMachineScaleSet.id;\n    this.name = azurermLinuxVirtualMachineScaleSet.name;\n    this.fqn = azurermLinuxVirtualMachineScaleSet.fqn;\n\n    // Enable SSH Azure AD Login if specified\n    if (props.enableSshAzureADLogin) {\n      new VirtualMachineScaleSetExtensionA(this, \"AADSSHlogin\", {\n        name: \"AADSSHLoginForLinux\",\n        virtualMachineScaleSetId: this.id,\n        publisher: \"Microsoft.Azure.ActiveDirectory\",\n        type: \"AADSSHLoginForLinux\",\n        typeHandlerVersion: \"1.0\",\n      });\n    }\n  }\n}\n\nexport interface WindowsClusterProps {\n  /**\n   * The Azure location where the virtual machine should be created.\n   * @default \"eastus\"\n   */\n  readonly location?: string;\n\n  /**\n   * The name of the virtual machine.\n   * @default - Uses the name derived from the construct path.\n   */\n  readonly name?: string;\n\n  /**\n   * The name of the resource group in which the virtual machine will be created.\n   */\n  readonly resourceGroup: ResourceGroup;\n\n  /**\n   * The size of the virtual machine.\n   * @default \"Standard_B2s\"\n   */\n  readonly sku?: string;\n\n  /**\n   * The admin username for the virtual machine.\n   */\n  readonly adminUsername: string;\n\n  /**\n   * The admin password for the virtual machine.\n   */\n  readonly adminPassword: string;\n\n  /**\n   * The availability zone(s) in which the VMs should be placed.\n   */\n  readonly zones?: string[];\n\n  /**\n   * The number of VM instances in the scale set.\n   * @default 2\n   */\n  readonly instances?: number;\n\n  /**\n   * The source image reference for the virtual machine.\n   * @default - Uses WindowsServer2022DatacenterCore.\n   */\n  readonly sourceImageReference?: WindowsVirtualMachineSourceImageReference;\n\n  /**\n   * The ID of the source image for the virtual machine.\n   */\n  readonly sourceImageId?: string;\n\n  /**\n   * Tags to apply to the virtual machine.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * The OS disk configuration for the virtual machine.\n   * @default - Uses a disk with caching set to \"ReadWrite\" and storage account type \"Standard_LRS\".\n   */\n  readonly osDisk?: WindowsVirtualMachineOsDisk;\n\n  /**\n   * The subnet in which the virtual machine will be placed.\n   * @default - Uses the default subnet from a new virtual network.\n   */\n  readonly subnet?: Subnet;\n\n  /**\n   * The allocation method for the public IP.\n   */\n  readonly publicIPAddress?: WindowsVirtualMachineScaleSetNetworkInterfaceIpConfigurationPublicIpAddress[];\n\n  /**\n   * Specifies the scale set's upgrade policy settings.\n   */\n  readonly upgradePolicyMode?: string;\n\n  /**\n   * Custom data to pass to the virtual machine upon creation.\n   */\n  readonly customData?: string;\n\n  /**\n   * Custom data to bootstrap the virtual machine. Automatically triggers Azure Custom Script extension to deploy code in custom data.\n   */\n  readonly boostrapCustomData?: string;\n\n  /**\n   * Bootdiagnostics settings for the VM.\n   */\n  readonly bootDiagnosticsStorageURI?: string;\n\n  /**\n   * Specifies if the VMSS should be overprovisioned.\n   * @default true\n   */\n  readonly overprovision?: boolean;\n\n  /**\n   * Specifies the scale-in policy for the VMSS.\n   */\n  readonly scaleInPolicy?: string;\n}\n\nexport class WindowsCluster extends AzureResource {\n  readonly props: WindowsClusterProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  public readonly name: string;\n\n  /**\n   * Represents a Windows Virtual Machine Scale Set (VMSS) within Microsoft Azure.\n   *\n   * This class provides a way to deploy and manage a scale set of Windows virtual machines, allowing for configurations such as\n   * auto-scaling, high availability, and simplified patch management. It supports detailed specifications including\n   * VM size, the operating system image, network settings, and administrative credentials. Additional capabilities include\n   * custom data scripts, automatic OS updates, and optional features like managed identity and boot diagnostics.\n   *\n   * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) application.\n   * @param id - The unique identifier for this instance of the Windows cluster, used within the scope for reference.\n   * @param props - Configuration properties for the Windows VM Scale Set, derived from the WindowsClusterProps interface. These include:\n   *                - `location`: The geographic location where the scale set will be hosted (e.g., \"eastus\").\n   *                - `name`: The name of the scale set, which must be unique within the resource group.\n   *                - `resourceGroup`: The ResourceGroup within which the scale set will be created.\n   *                - `sku`: The size specification of the VMs (e.g., \"Standard_B2s\").\n   *                - `adminUsername`: The administrator username for the VMs.\n   *                - `adminPassword`: The administrator password for the VMs.\n   *                - `zones`: The availability zones for deploying the VMs.\n   *                - `instances`: The number of VM instances in the scale set.\n   *                - `sourceImageReference`: A reference to the specific Windows image to be used for the VMs.\n   *                - `sourceImageId`: The identifier for a custom image to use for the VMs.\n   *                - `tags`: Key-value pairs for resource tagging.\n   *                - `osDisk`: Configuration for the VMs' operating system disks.\n   *                - `subnet`: Specifies the subnet within which the VMs will be placed.\n   *                - `publicIPAddress`: Method used to allocate public IP addresses to the VMs.\n   *                - `customData`: Scripts or commands passed to the VMs at startup.\n   *                - `upgradePolicyMode`: The upgrade policy mode for the VMSS.\n   *                - `overprovision`: Specifies if the VMSS should be overprovisioned to maintain capacity during updates.\n   *                - `scaleInPolicy`: The scale-in policy for the VMSS.\n   *                - `bootDiagnosticsStorageURI`: URI for storage where VMSS boot diagnostics are collected.\n   *                - `enableSshAzureADLogin`: Option to enable Azure AD login for SSH on the VMs.\n   *\n   * Example usage:\n   * ```typescript\n   * const windowsCluster = new WindowsCluster(this, 'MyWindowsCluster', {\n   *   resourceGroup: myResourceGroup,\n   *   name: 'myCluster',\n   *   sku: 'Standard_DS1_v2',\n   *   adminUsername: 'adminuser',\n   *   adminPassword: 'securepassword123',\n   *   sourceImageReference: { publisher: 'MicrosoftWindowsServer', offer: 'WindowsServer', sku: '2019-Datacenter', version: 'latest' },\n   *   osDisk: { caching: 'ReadWrite', storageAccountType: 'Standard_LRS' },\n   *   subnet: mySubnet,\n   *   instances: 3,\n   *   tags: { environment: 'production' }\n   * });\n   * ```\n   * This class initializes a Windows VM Scale Set with the specified configurations, handling details like VM creation,\n   * scaling policies, network setup, OS installation, and security settings, providing a robust and scalable infrastructure\n   * for hosting cloud-based Windows applications.\n   */\n  constructor(scope: Construct, id: string, props: WindowsClusterProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    const pathName = this.node.path.split(\"/\")[0];\n\n    // Default configurations for the virtual machine.\n    const defaults = {\n      name: props.name || this.node.path.split(\"/\")[0],\n      adminUsername: props.adminUsername || `admin${pathName}`,\n      location: props.location || \"eastus\",\n      sku: props.sku || \"Standard_B2s\",\n      instances: props.instances || 1,\n      osDisk: props.osDisk || {\n        caching: \"ReadWrite\",\n        storageAccountType: \"Standard_LRS\",\n      },\n      sourceImageReference:\n        props.sourceImageReference ||\n        WindowsImageReferences.windowsServer2022DatacenterCore,\n      subnet:\n        props.subnet ||\n        new Network(this, \"vnet\", {\n          resourceGroup: props.resourceGroup,\n        }).subnets.default,\n    };\n\n    // Base64 encode custom data if provided.\n    const customData = props.customData || props.boostrapCustomData;\n    const base64CustomData = customData\n      ? Buffer.from(customData).toString(\"base64\")\n      : undefined;\n\n    // Create the Windows Virtual Machine.\n    const azurermWindowsVirtualMachine = new WindowsVirtualMachineScaleSet(\n      this,\n      \"vmss\",\n      {\n        ...defaults,\n        resourceGroupName: props.resourceGroup.name,\n        adminUsername: props.adminUsername,\n        adminPassword: props.adminPassword,\n        tags: props.tags,\n        networkInterface: [\n          {\n            name: `nic-${defaults.name}`,\n            primary: true,\n            ipConfiguration: [\n              {\n                name: \"internal\",\n                subnetId: defaults.subnet.id,\n                primary: true,\n                publicIpAddress: props.publicIPAddress,\n              },\n            ],\n          },\n        ],\n        osDisk: {\n          ...defaults.osDisk,\n        },\n        sourceImageId: props.sourceImageId,\n        customData: base64CustomData,\n        bootDiagnostics: { storageAccountUri: props.bootDiagnosticsStorageURI },\n      },\n    );\n\n    this.id = azurermWindowsVirtualMachine.id;\n    this.name = azurermWindowsVirtualMachine.name;\n\n    // Bootstrap VM with custom script extension if bootstrap custom data is provided.\n    if (props.boostrapCustomData) {\n      new VirtualMachineScaleSetExtensionA(this, \"script-ext\", {\n        name: `${this.name}-script-ext`,\n        virtualMachineScaleSetId: this.id,\n        publisher: \"Microsoft.Compute\",\n        type: \"CustomScriptExtension\",\n        typeHandlerVersion: \"1.10\",\n        protectedSettings:\n          '{\"commandToExecute\": \"rename  C:\\\\\\\\AzureData\\\\\\\\CustomData.bin  postdeploy.ps1 & powershell -ExecutionPolicy Unrestricted -File C:\\\\\\\\AzureData\\\\\\\\postdeploy.ps1\"}',\n      });\n    }\n  }\n}\n"]}

package/lib/azure-virtualmachinescaleset/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./cluster";

package/lib/azure-virtualmachinescaleset/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cluster"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtdmlydHVhbG1hY2hpbmVzY2FsZXNldC9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NsdXN0ZXJcIjtcbiJdfQ==

package/lib/azure-virtualmachinescaleset/test/AzureLinuxVirtualMachineScaleSet.spec.d.ts

@@ -0,0 +1 @@
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-virtualmachinescaleset/test/AzureLinuxVirtualMachineScaleSet.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const vmss = require("..");
+const ExampleAzureLinuxVirtualMachineScaleSet_1 = require("../test/ExampleAzureLinuxVirtualMachineScaleSet");
+describe("Azure Linux Virtual Machine Scale Set With Defaults", () => {
+    let stack;
+    let fullSynthResult;
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "testAzureVMSSWithDefaults");
+        new provider_1.AzurermProvider(stack, "azureFeature", { features: {} });
+        const rg = new resource_group_1.ResourceGroup(stack, "MyResourceGroup", {
+            name: "rg-test",
+            location: "eastus",
+        });
+        new vmss.LinuxCluster(stack, "testVirtualMachineScaleSet", {
+            resourceGroup: rg,
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Linux Virtual Machine  Scale Set with defaults and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(stack)).toMatchSnapshot(); // Compare the already prepared stack
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        expect(fullSynthResult).toBeValidTerraform(); // Use the saved result
+    });
+    it("check if this can be planned", () => {
+        expect(fullSynthResult).toPlanSuccessfully(); // Use the saved result
+    });
+});
+describe("Azure Linux Virtual Machine  Scale Set Example", () => {
+    it("renders the Azure Linux Virtual Machine Scale Set and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(new ExampleAzureLinuxVirtualMachineScaleSet_1.exampleAzureLinuxVirtualMachineScaleSet(cdktf_1.Testing.app(), "testAzureLinuxVirtualMachineScaleSetExample"))).toMatchSnapshot();
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureLinuxVirtualMachineScaleSet_1.exampleAzureLinuxVirtualMachineScaleSet(cdktf_1.Testing.app(), "testAzureLinuxVirtualMachineScaleSetExample"))).toBeValidTerraform();
+    });
+    it("check if this can be planned", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureLinuxVirtualMachineScaleSet_1.exampleAzureLinuxVirtualMachineScaleSet(cdktf_1.Testing.app(), "testAzureLinuxVirtualMachineScaleSetExample"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-virtualmachinescaleset/test/AzureWindowsVirtualMachineScaleSet.spec.d.ts

@@ -0,0 +1 @@
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-virtualmachinescaleset/test/AzureWindowsVirtualMachineScaleSet.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const vmss = require("..");
+const ExampleAzureWindowsVirtualMachineScaleSet_1 = require("../test/ExampleAzureWindowsVirtualMachineScaleSet");
+describe("Azure Windows Virtual Machine Scale Set With Defaults", () => {
+    let stack;
+    let fullSynthResult;
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "testAzureVMSSWithDefaults");
+        new provider_1.AzurermProvider(stack, "azureFeature", { features: {} });
+        const rg = new resource_group_1.ResourceGroup(stack, "MyResourceGroup", {
+            name: "rg-test",
+            location: "eastus",
+        });
+        new vmss.WindowsCluster(stack, "testVirtualMachineScaleSet", {
+            resourceGroup: rg,
+            adminUsername: "testAdmin",
+            adminPassword: "testPassword&@34$$123",
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Windows Virtual Machine  Scale Set with defaults and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(stack)).toMatchSnapshot(); // Compare the already prepared stack
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        expect(fullSynthResult).toBeValidTerraform(); // Use the saved result
+    });
+    it("check if this can be planned", () => {
+        expect(fullSynthResult).toPlanSuccessfully(); // Use the saved result
+    });
+});
+describe("Azure Windows Virtual Machine  Scale Set Example", () => {
+    it("renders the Azure Windows Virtual Machine Scale Set and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(new ExampleAzureWindowsVirtualMachineScaleSet_1.exampleAzureWindowsVirtualMachineScaleSet(cdktf_1.Testing.app(), "testAzureWindowsVirtualMachineScaleSetExample"))).toMatchSnapshot();
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureWindowsVirtualMachineScaleSet_1.exampleAzureWindowsVirtualMachineScaleSet(cdktf_1.Testing.app(), "testAzureWindowsVirtualMachineScaleSetExample"))).toBeValidTerraform();
+    });
+    it("check if this can be planned", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureWindowsVirtualMachineScaleSet_1.exampleAzureWindowsVirtualMachineScaleSet(cdktf_1.Testing.app(), "testAzureWindowsVirtualMachineScaleSetExample"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-virtualmachinescaleset/test/ExampleAzureLinuxVirtualMachineScaleSet.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { BaseTestStack } from "../../testing";
+export declare class exampleAzureLinuxVirtualMachineScaleSet extends BaseTestStack {
+    constructor(scope: Construct, id: string);
+}

package/lib/azure-virtualmachinescaleset/test/ExampleAzureLinuxVirtualMachineScaleSet.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleAzureLinuxVirtualMachineScaleSet = void 0;
+const data_azurerm_client_config_1 = require("@cdktf/provider-azurerm/lib/data-azurerm-client-config");
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const storage_account_1 = require("@cdktf/provider-azurerm/lib/storage-account");
+const subnet_1 = require("@cdktf/provider-azurerm/lib/subnet");
+const virtual_network_1 = require("@cdktf/provider-azurerm/lib/virtual-network");
+const cdktf = require("cdktf");
+const cdktf_1 = require("cdktf");
+const vmss = require("..");
+const testing_1 = require("../../testing");
+const app = new cdktf_1.App();
+class exampleAzureLinuxVirtualMachineScaleSet extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id);
+        const clientConfig = new data_azurerm_client_config_1.DataAzurermClientConfig(this, "CurrentClientConfig", {});
+        new provider_1.AzurermProvider(this, "azureFeature", {
+            features: {},
+        });
+        const resourceGroup = new resource_group_1.ResourceGroup(this, "rg", {
+            location: "eastus",
+            name: `rg-${this.name}`,
+        });
+        const vnet = new virtual_network_1.VirtualNetwork(this, "vnet", {
+            name: `vnet-${this.name}`,
+            location: resourceGroup.location,
+            resourceGroupName: resourceGroup.name,
+            addressSpace: ["10.0.0.0/16"],
+        });
+        const subnet = new subnet_1.Subnet(this, "subnet1", {
+            name: "subnet1",
+            resourceGroupName: resourceGroup.name,
+            virtualNetworkName: vnet.name,
+            addressPrefixes: ["10.0.1.0/24"],
+        });
+        const storage = new storage_account_1.StorageAccount(this, "storage", {
+            name: `sta${this.name}88r93`,
+            resourceGroupName: resourceGroup.name,
+            location: resourceGroup.location,
+            accountReplicationType: "LRS",
+            accountTier: "Standard",
+            minTlsVersion: "TLS1_2",
+            publicNetworkAccessEnabled: false,
+            networkRules: {
+                bypass: ["AzureServices"],
+                defaultAction: "Deny",
+            },
+        });
+        const vm = new vmss.LinuxCluster(this, "vm", {
+            name: this.name,
+            location: "eastus",
+            resourceGroup: resourceGroup,
+            sku: "Standard_B1s",
+            adminUsername: "testadmin",
+            adminPassword: "Password1234!",
+            osDisk: {
+                caching: "ReadWrite",
+                storageAccountType: "Standard_LRS",
+            },
+            sourceImageReference: {
+                publisher: "Canonical",
+                offer: "0001-com-ubuntu-server-jammy",
+                sku: "22_04-lts-gen2",
+                version: "latest",
+            },
+            subnet: subnet,
+            publicIPAddress: [
+                {
+                    name: "testpublicip",
+                },
+            ],
+            userData: "#!/bin/bash\nsudo apt-get install -y apache2",
+            enableSshAzureADLogin: true,
+            identity: {
+                type: "SystemAssigned",
+            },
+            bootDiagnosticsStorageURI: storage.primaryBlobEndpoint,
+        });
+        // Diag Settings
+        vm.addDiagSettings({ name: "diagsettings", storageAccountId: storage.id });
+        // RBAC
+        vm.addAccess(clientConfig.objectId, "Contributor");
+        // Outputs to use for End to End Test
+        const cdktfTerraformOutputRGName = new cdktf.TerraformOutput(this, "resource_group_name", {
+            value: resourceGroup.name,
+        });
+        const cdktfTerraformOutputNsgName = new cdktf.TerraformOutput(this, "vm_name", {
+            value: vm.name,
+        });
+        const cdktfTerraformOutputVmsize = new cdktf.TerraformOutput(this, "vm_size", {
+            value: "Standard_B1s",
+        });
+        const cdktfTerraformOutputVmEndpoint = new cdktf.TerraformOutput(this, "public_ip_name", {
+            value: "testpublicip",
+        });
+        cdktfTerraformOutputRGName.overrideLogicalId("resource_group_name");
+        cdktfTerraformOutputNsgName.overrideLogicalId("vm_name");
+        cdktfTerraformOutputVmsize.overrideLogicalId("vm_size");
+        cdktfTerraformOutputVmEndpoint.overrideLogicalId("public_ip_name");
+    }
+}
+exports.exampleAzureLinuxVirtualMachineScaleSet = exampleAzureLinuxVirtualMachineScaleSet;
+new exampleAzureLinuxVirtualMachineScaleSet(app, "testAzureLinuxVirtualMachineScaleSetExample");
+app.synth();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExampleAzureLinuxVirtualMachineScaleSet.js","sourceRoot":"","sources":["../../../src/azure-virtualmachinescaleset/test/ExampleAzureLinuxVirtualMachineScaleSet.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataAzurermClientConfig } from \"@cdktf/provider-azurerm/lib/data-azurerm-client-config\";\nimport { AzurermProvider } from \"@cdktf/provider-azurerm/lib/provider\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { StorageAccount } from \"@cdktf/provider-azurerm/lib/storage-account\";\nimport { Subnet } from \"@cdktf/provider-azurerm/lib/subnet\";\nimport { VirtualNetwork } from \"@cdktf/provider-azurerm/lib/virtual-network\";\nimport * as cdktf from \"cdktf\";\nimport { App } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as vmss from \"..\";\nimport { BaseTestStack } from \"../../testing\";\n\nconst app = new App();\n\nexport class exampleAzureLinuxVirtualMachineScaleSet extends BaseTestStack {\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n\n    const clientConfig = new DataAzurermClientConfig(\n      this,\n      \"CurrentClientConfig\",\n      {},\n    );\n\n    new AzurermProvider(this, \"azureFeature\", {\n      features: {},\n    });\n\n    const resourceGroup = new ResourceGroup(this, \"rg\", {\n      location: \"eastus\",\n      name: `rg-${this.name}`,\n    });\n\n    const vnet = new VirtualNetwork(this, \"vnet\", {\n      name: `vnet-${this.name}`,\n      location: resourceGroup.location,\n      resourceGroupName: resourceGroup.name,\n      addressSpace: [\"10.0.0.0/16\"],\n    });\n\n    const subnet = new Subnet(this, \"subnet1\", {\n      name: \"subnet1\",\n      resourceGroupName: resourceGroup.name,\n      virtualNetworkName: vnet.name,\n      addressPrefixes: [\"10.0.1.0/24\"],\n    });\n\n    const storage = new StorageAccount(this, \"storage\", {\n      name: `sta${this.name}88r93`,\n      resourceGroupName: resourceGroup.name,\n      location: resourceGroup.location,\n      accountReplicationType: \"LRS\",\n      accountTier: \"Standard\",\n      minTlsVersion: \"TLS1_2\",\n      publicNetworkAccessEnabled: false,\n      networkRules: {\n        bypass: [\"AzureServices\"],\n        defaultAction: \"Deny\",\n      },\n    });\n\n    const vm = new vmss.LinuxCluster(this, \"vm\", {\n      name: this.name,\n      location: \"eastus\",\n      resourceGroup: resourceGroup,\n      sku: \"Standard_B1s\",\n      adminUsername: \"testadmin\",\n      adminPassword: \"Password1234!\",\n      osDisk: {\n        caching: \"ReadWrite\",\n        storageAccountType: \"Standard_LRS\",\n      },\n      sourceImageReference: {\n        publisher: \"Canonical\",\n        offer: \"0001-com-ubuntu-server-jammy\",\n        sku: \"22_04-lts-gen2\",\n        version: \"latest\",\n      },\n      subnet: subnet,\n      publicIPAddress: [\n        {\n          name: \"testpublicip\",\n        },\n      ],\n      userData: \"#!/bin/bash\\nsudo apt-get install -y apache2\",\n      enableSshAzureADLogin: true,\n      identity: {\n        type: \"SystemAssigned\",\n      },\n      bootDiagnosticsStorageURI: storage.primaryBlobEndpoint,\n    });\n\n    // Diag Settings\n    vm.addDiagSettings({ name: \"diagsettings\", storageAccountId: storage.id });\n\n    // RBAC\n    vm.addAccess(clientConfig.objectId, \"Contributor\");\n\n    // Outputs to use for End to End Test\n    const cdktfTerraformOutputRGName = new cdktf.TerraformOutput(\n      this,\n      \"resource_group_name\",\n      {\n        value: resourceGroup.name,\n      },\n    );\n\n    const cdktfTerraformOutputNsgName = new cdktf.TerraformOutput(\n      this,\n      \"vm_name\",\n      {\n        value: vm.name,\n      },\n    );\n\n    const cdktfTerraformOutputVmsize = new cdktf.TerraformOutput(\n      this,\n      \"vm_size\",\n      {\n        value: \"Standard_B1s\",\n      },\n    );\n\n    const cdktfTerraformOutputVmEndpoint = new cdktf.TerraformOutput(\n      this,\n      \"public_ip_name\",\n      {\n        value: \"testpublicip\",\n      },\n    );\n\n    cdktfTerraformOutputRGName.overrideLogicalId(\"resource_group_name\");\n    cdktfTerraformOutputNsgName.overrideLogicalId(\"vm_name\");\n    cdktfTerraformOutputVmsize.overrideLogicalId(\"vm_size\");\n    cdktfTerraformOutputVmEndpoint.overrideLogicalId(\"public_ip_name\");\n  }\n}\n\nnew exampleAzureLinuxVirtualMachineScaleSet(\n  app,\n  \"testAzureLinuxVirtualMachineScaleSetExample\",\n);\n\napp.synth();\n"]}

package/lib/azure-virtualmachinescaleset/test/ExampleAzureWindowsVirtualMachineScaleSet.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { BaseTestStack } from "../../testing";
+export declare class exampleAzureWindowsVirtualMachineScaleSet extends BaseTestStack {
+    constructor(scope: Construct, id: string);
+}