@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/azure-virtualmachine/lib/virtual-machine.js

@@ -0,0 +1,462 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualMachine = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Virtual Machine implementation using VersionedAzapiResource framework
+ *
+ * This class provides a single, version-aware implementation for Azure Virtual Machines
+ * that automatically handles version management, schema validation, and property transformation
+ * across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2024-07-01 (Active)
+ * - 2024-11-01 (Active)
+ * - 2025-04-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full JSII compliance for multi-language support
+ * - Comprehensive support for VM features (networking, storage, identity, etc.)
+ */
+const cdktf = require("cdktf");
+const virtual_machine_schemas_1 = require("./virtual-machine-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+/**
+ * Unified Azure Virtual Machine implementation
+ *
+ * This class provides a single, version-aware implementation that automatically handles version
+ * resolution, schema validation, and property transformation while maintaining full JSII compliance.
+ *
+ * The class uses the VersionedAzapiResource framework to provide:
+ * - Automatic latest version resolution (2025-04-01 as of this implementation)
+ * - Support for explicit version pinning when stability is required
+ * - Schema-driven property validation and transformation
+ * - Migration analysis and deprecation warnings
+ * - Full JSII compliance for multi-language support
+ *
+ * @example
+ * // Basic Linux VM with SSH authentication:
+ * const vm = new VirtualMachine(this, "vm", {
+ *   name: "my-linux-vm",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   hardwareProfile: {
+ *     vmSize: "Standard_D2s_v3"
+ *   },
+ *   storageProfile: {
+ *     imageReference: {
+ *       publisher: "Canonical",
+ *       offer: "0001-com-ubuntu-server-jammy",
+ *       sku: "22_04-lts-gen2",
+ *       version: "latest"
+ *     },
+ *     osDisk: {
+ *       createOption: "FromImage",
+ *       managedDisk: {
+ *         storageAccountType: "Premium_LRS"
+ *       }
+ *     }
+ *   },
+ *   osProfile: {
+ *     computerName: "myvm",
+ *     adminUsername: "azureuser",
+ *     linuxConfiguration: {
+ *       disablePasswordAuthentication: true,
+ *       ssh: {
+ *         publicKeys: [{
+ *           path: "/home/azureuser/.ssh/authorized_keys",
+ *           keyData: "ssh-rsa AAAA..."
+ *         }]
+ *       }
+ *     }
+ *   },
+ *   networkProfile: {
+ *     networkInterfaces: [{
+ *       id: networkInterface.id
+ *     }]
+ *   },
+ *   identity: {
+ *     type: "SystemAssigned"
+ *   }
+ * });
+ *
+ * @example
+ * // Windows VM with password authentication:
+ * const windowsVm = new VirtualMachine(this, "windows-vm", {
+ *   name: "my-windows-vm",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   hardwareProfile: {
+ *     vmSize: "Standard_D2s_v3"
+ *   },
+ *   storageProfile: {
+ *     imageReference: {
+ *       publisher: "MicrosoftWindowsServer",
+ *       offer: "WindowsServer",
+ *       sku: "2022-datacenter-azure-edition",
+ *       version: "latest"
+ *     },
+ *     osDisk: {
+ *       createOption: "FromImage",
+ *       managedDisk: {
+ *         storageAccountType: "Premium_LRS"
+ *       }
+ *     }
+ *   },
+ *   osProfile: {
+ *     computerName: "mywinvm",
+ *     adminUsername: "azureuser",
+ *     adminPassword: "P@ssw0rd1234!",
+ *     windowsConfiguration: {
+ *       provisionVMAgent: true,
+ *       enableAutomaticUpdates: true
+ *     }
+ *   },
+ *   networkProfile: {
+ *     networkInterfaces: [{
+ *       id: networkInterface.id
+ *     }]
+ *   },
+ *   licenseType: "Windows_Server"
+ * });
+ *
+ * @stability stable
+ */
+class VirtualMachine extends azapi_resource_1.AzapiResource {
+    /**
+     * Returns a production-ready monitoring configuration for Virtual Machines
+     *
+     * This static factory method provides a complete MonitoringConfig with sensible defaults
+     * for VM monitoring including CPU, memory, disk queue alerts, and deletion tracking.
+     *
+     * @param actionGroupId - The resource ID of the action group for alert notifications
+     * @param workspaceId - Optional Log Analytics workspace ID for diagnostic settings
+     * @param options - Optional configuration to customize thresholds and enable/disable specific alerts
+     * @returns A complete MonitoringConfig object ready to use in VirtualMachine props
+     *
+     * @example
+     * // Basic usage with all defaults
+     * const vm = new VirtualMachine(this, "vm", {
+     *   // ... other properties ...
+     *   monitoring: VirtualMachine.defaultMonitoring(actionGroup.id, workspace.id)
+     * });
+     *
+     * @example
+     * // Custom thresholds
+     * const vm = new VirtualMachine(this, "vm", {
+     *   // ... other properties ...
+     *   monitoring: VirtualMachine.defaultMonitoring(
+     *     actionGroup.id,
+     *     workspace.id,
+     *     {
+     *       cpuThreshold: 90,
+     *       memoryThreshold: 536870912, // 512MB
+     *       enableDiskQueueAlert: false
+     *     }
+     *   )
+     * });
+     */
+    static defaultMonitoring(actionGroupId, workspaceId, options) {
+        const metricAlerts = [];
+        // High CPU Alert
+        if (options?.enableCpuAlert !== false) {
+            metricAlerts.push({
+                name: "high-cpu-alert",
+                description: "Alert when CPU usage exceeds threshold",
+                severity: (options?.cpuAlertSeverity ?? 2),
+                scopes: [], // Will be set automatically by base class
+                evaluationFrequency: "PT5M",
+                windowSize: "PT15M",
+                criteria: {
+                    type: "StaticThreshold",
+                    metricName: "Percentage CPU",
+                    metricNamespace: "Microsoft.Compute/virtualMachines",
+                    operator: "GreaterThan",
+                    threshold: options?.cpuThreshold ?? 80,
+                    timeAggregation: "Average",
+                },
+                actions: [{ actionGroupId }],
+            });
+        }
+        // Low Memory Alert
+        if (options?.enableMemoryAlert !== false) {
+            metricAlerts.push({
+                name: "low-memory-alert",
+                description: "Alert when available memory falls below threshold",
+                severity: (options?.memoryAlertSeverity ?? 2),
+                scopes: [], // Will be set automatically by base class
+                evaluationFrequency: "PT5M",
+                windowSize: "PT15M",
+                criteria: {
+                    type: "StaticThreshold",
+                    metricName: "Available Memory Bytes",
+                    metricNamespace: "Microsoft.Compute/virtualMachines",
+                    operator: "LessThan",
+                    threshold: options?.memoryThreshold ?? 1073741824,
+                    timeAggregation: "Average",
+                },
+                actions: [{ actionGroupId }],
+            });
+        }
+        // High Disk Queue Alert
+        if (options?.enableDiskQueueAlert !== false) {
+            metricAlerts.push({
+                name: "high-disk-queue-alert",
+                description: "Alert when disk queue depth exceeds threshold",
+                severity: (options?.diskQueueAlertSeverity ?? 2),
+                scopes: [], // Will be set automatically by base class
+                evaluationFrequency: "PT5M",
+                windowSize: "PT15M",
+                criteria: {
+                    type: "StaticThreshold",
+                    metricName: "OS Disk Queue Depth",
+                    metricNamespace: "Microsoft.Compute/virtualMachines",
+                    operator: "GreaterThan",
+                    threshold: options?.diskQueueThreshold ?? 32,
+                    timeAggregation: "Average",
+                },
+                actions: [{ actionGroupId }],
+            });
+        }
+        // Build diagnostic settings if workspace ID is provided
+        const diagnosticSettings = workspaceId
+            ? {
+                name: "vm-diagnostics",
+                targetResourceId: "", // Will be set automatically by base class
+                workspaceId: workspaceId,
+                logs: [{ categoryGroup: "allLogs", enabled: true }],
+                metrics: [{ category: "AllMetrics", enabled: true }],
+            }
+            : undefined;
+        // Build activity log alerts
+        const activityLogAlerts = options?.enableDeletionAlert !== false
+            ? [
+                {
+                    name: "vm-deletion-alert",
+                    description: "Alert when virtual machine is deleted",
+                    scopes: [], // Will be set automatically by base class
+                    condition: {
+                        allOf: [
+                            {
+                                field: "operationName",
+                                equalsValue: "Microsoft.Compute/virtualMachines/delete",
+                            },
+                        ],
+                    },
+                    actions: {
+                        actionGroups: [{ actionGroupId }],
+                    },
+                },
+            ]
+            : undefined;
+        // Return complete config object
+        return {
+            enabled: true,
+            diagnosticSettings: diagnosticSettings,
+            metricAlerts: metricAlerts,
+            activityLogAlerts: activityLogAlerts,
+        };
+    }
+    /**
+     * Ensures that Virtual Machine schemas are registered with the ApiVersionManager
+     * This is called once during the first VirtualMachine instantiation
+     */
+    static ensureSchemasRegistered() {
+        if (VirtualMachine.schemasRegistered) {
+            return;
+        }
+        const apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            // Register all Virtual Machine versions
+            apiVersionManager.registerResourceType(virtual_machine_schemas_1.VIRTUAL_MACHINE_TYPE, virtual_machine_schemas_1.ALL_VIRTUAL_MACHINE_VERSIONS);
+            VirtualMachine.schemasRegistered = true;
+            console.log(`Registered ${virtual_machine_schemas_1.ALL_VIRTUAL_MACHINE_VERSIONS.length} API versions for ${virtual_machine_schemas_1.VIRTUAL_MACHINE_TYPE}`);
+        }
+        catch (error) {
+            console.warn(`Failed to register Virtual Machine schemas: ${error}. ` +
+                `This may indicate the schemas are already registered or there's a configuration issue.`);
+            // Don't throw here as the schemas might already be registered
+            VirtualMachine.schemasRegistered = true;
+        }
+    }
+    /**
+     * Creates a new Azure Virtual Machine using the VersionedAzapiResource framework
+     *
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Virtual Machine
+     */
+    constructor(scope, id, props) {
+        // Ensure schemas are registered before calling super
+        VirtualMachine.ensureSchemasRegistered();
+        // Call the parent constructor with the props
+        super(scope, id, props);
+        this.props = props;
+        // Extract properties from the AZAPI resource outputs using Terraform interpolation
+        this.id = `\${${this.terraformResource.fqn}.id}`;
+        this.tags = props.tags || {};
+        // Create Terraform outputs for easy access and referencing from other resources
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Virtual Machine",
+        });
+        this.locationOutput = new cdktf.TerraformOutput(this, "location", {
+            value: `\${${this.terraformResource.fqn}.location}`,
+            description: "The location of the Virtual Machine",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Virtual Machine",
+        });
+        this.tagsOutput = new cdktf.TerraformOutput(this, "tags", {
+            value: `\${${this.terraformResource.fqn}.tags}`,
+            description: "The tags assigned to the Virtual Machine",
+        });
+        this.vmIdOutput = new cdktf.TerraformOutput(this, "vmId", {
+            value: `\${${this.terraformResource.fqn}.output.properties.vmId}`,
+            description: "The unique identifier of the Virtual Machine",
+        });
+        // Override logical IDs to match naming convention
+        this.idOutput.overrideLogicalId("id");
+        this.locationOutput.overrideLogicalId("location");
+        this.nameOutput.overrideLogicalId("name");
+        this.tagsOutput.overrideLogicalId("tags");
+        this.vmIdOutput.overrideLogicalId("vmId");
+        // Apply ignore changes if specified
+        this._applyIgnoreChanges();
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the most recent stable version as the default
+     */
+    defaultVersion() {
+        return "2025-04-01";
+    }
+    /**
+     * Gets the Azure resource type for Virtual Machines
+     */
+    resourceType() {
+        return virtual_machine_schemas_1.VIRTUAL_MACHINE_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     * Uses the framework's schema resolution to get the appropriate schema
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     * Transforms the input properties into the JSON format expected by Azure REST API
+     */
+    createResourceBody(props) {
+        const typedProps = props;
+        return {
+            location: typedProps.location || "eastus",
+            tags: typedProps.tags || {},
+            identity: typedProps.identity,
+            zones: typedProps.zones,
+            plan: typedProps.plan,
+            properties: {
+                hardwareProfile: typedProps.hardwareProfile,
+                storageProfile: typedProps.storageProfile,
+                osProfile: typedProps.osProfile,
+                networkProfile: typedProps.networkProfile,
+                diagnosticsProfile: typedProps.diagnosticsProfile,
+                availabilitySet: typedProps.availabilitySet,
+                virtualMachineScaleSet: typedProps.virtualMachineScaleSet,
+                proximityPlacementGroup: typedProps.proximityPlacementGroup,
+                priority: typedProps.priority,
+                evictionPolicy: typedProps.evictionPolicy,
+                billingProfile: typedProps.billingProfile,
+                host: typedProps.host,
+                licenseType: typedProps.licenseType,
+                additionalCapabilities: typedProps.additionalCapabilities,
+                securityProfile: typedProps.securityProfile,
+            },
+        };
+    }
+    // =============================================================================
+    // PUBLIC METHODS FOR VIRTUAL MACHINE OPERATIONS
+    // =============================================================================
+    /**
+     * Get the VM ID (unique identifier assigned by Azure)
+     */
+    get vmId() {
+        return `\${${this.terraformResource.fqn}.output.properties.vmId}`;
+    }
+    /**
+     * Get the provisioning state of the Virtual Machine
+     */
+    get provisioningState() {
+        return `\${${this.terraformResource.fqn}.output.properties.provisioningState}`;
+    }
+    /**
+     * Get the OS profile computer name
+     */
+    get computerName() {
+        return this.props.osProfile?.computerName;
+    }
+    /**
+     * Get the VM size
+     */
+    get vmSize() {
+        return this.props.hardwareProfile.vmSize;
+    }
+    /**
+     * Add a tag to the Virtual Machine
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    addTag(key, value) {
+        if (!this.props.tags) {
+            this.props.tags = {};
+        }
+        this.props.tags[key] = value;
+    }
+    /**
+     * Remove a tag from the Virtual Machine
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    removeTag(key) {
+        if (this.props.tags && this.props.tags[key]) {
+            delete this.props.tags[key];
+        }
+    }
+    // =============================================================================
+    // PRIVATE HELPER METHODS
+    // =============================================================================
+    /**
+     * Applies ignore changes lifecycle rules if specified in props
+     */
+    _applyIgnoreChanges() {
+        if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {
+            // Common properties that are safe to ignore for Virtual Machines
+            // adminPassword should often be ignored to prevent drift
+            const validIgnoreChanges = this.props.ignoreChanges.filter((change) => change !== "name");
+            if (validIgnoreChanges.length > 0) {
+                this.terraformResource.addOverride("lifecycle", {
+                    ignore_changes: validIgnoreChanges,
+                });
+            }
+        }
+    }
+}
+exports.VirtualMachine = VirtualMachine;
+_a = JSII_RTTI_SYMBOL_1;
+VirtualMachine[_a] = { fqn: "@microsoft/terraform-cdk-constructs.VirtualMachine", version: "1.2.0" };
+/**
+ * Static initialization flag to ensure schemas are registered only once
+ */
+VirtualMachine.schemasRegistered = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-machine.js","sourceRoot":"","sources":["../../../src/azure-virtualmachine/lib/virtual-machine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Virtual Machine implementation using VersionedAzapiResource framework\n *\n * This class provides a single, version-aware implementation for Azure Virtual Machines\n * that automatically handles version management, schema validation, and property transformation\n * across all supported API versions.\n *\n * Supported API Versions:\n * - 2024-07-01 (Active)\n * - 2024-11-01 (Active)\n * - 2025-04-01 (Active, Latest)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Full JSII compliance for multi-language support\n * - Comprehensive support for VM features (networking, storage, identity, etc.)\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_VIRTUAL_MACHINE_VERSIONS,\n  VIRTUAL_MACHINE_TYPE,\n  VirtualMachineHardwareProfile,\n  VirtualMachineStorageProfile,\n  VirtualMachineNetworkProfile,\n  VirtualMachineOSProfile,\n  VirtualMachineIdentity,\n  VirtualMachinePlan,\n  VirtualMachineAdditionalCapabilities,\n  VirtualMachineDiagnosticsProfile,\n  VirtualMachineSecurityProfile,\n  VirtualMachineLicenseType,\n  VirtualMachineAvailabilitySetReference,\n  VirtualMachineScaleSetReference,\n  VirtualMachineProximityPlacementGroupReference,\n  VirtualMachineHostReference,\n  VirtualMachineBillingProfile,\n  VirtualMachineMonitoringOptions,\n} from \"./virtual-machine-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n  MonitoringConfig,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Properties for the unified Azure Virtual Machine\n *\n * Extends AzapiResourceProps with Virtual Machine specific properties\n */\nexport interface VirtualMachineProps extends AzapiResourceProps {\n  /**\n   * The hardware profile for the Virtual Machine (VM size)\n   * @example { vmSize: \"Standard_D2s_v3\" }\n   */\n  readonly hardwareProfile: VirtualMachineHardwareProfile;\n\n  /**\n   * The storage profile for the Virtual Machine\n   * Defines the OS disk, data disks, and image reference\n   */\n  readonly storageProfile: VirtualMachineStorageProfile;\n\n  /**\n   * The network profile for the Virtual Machine\n   * Defines network interfaces attached to the VM\n   */\n  readonly networkProfile: VirtualMachineNetworkProfile;\n\n  /**\n   * The OS profile for the Virtual Machine\n   * Defines computer name, admin credentials, and OS-specific configuration\n   */\n  readonly osProfile?: VirtualMachineOSProfile;\n\n  /**\n   * The identity configuration for the Virtual Machine\n   * @example { type: \"SystemAssigned\" }\n   * @example { type: \"UserAssigned\", userAssignedIdentities: { \"/subscriptions/.../resourceGroups/.../providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentity\": {} } }\n   */\n  readonly identity?: VirtualMachineIdentity;\n\n  /**\n   * Availability zones for the Virtual Machine\n   * @example [\"1\", \"2\"]\n   */\n  readonly zones?: string[];\n\n  /**\n   * Plan information for marketplace images\n   */\n  readonly plan?: VirtualMachinePlan;\n\n  /**\n   * License type for Windows VMs\n   * @example \"Windows_Server\"\n   * @example \"Windows_Client\"\n   */\n  readonly licenseType?: VirtualMachineLicenseType;\n\n  /**\n   * The priority of the Virtual Machine\n   * @default \"Regular\"\n   * @example \"Regular\", \"Low\", \"Spot\"\n   */\n  readonly priority?: string;\n\n  /**\n   * The eviction policy for Spot VMs\n   * @example \"Deallocate\", \"Delete\"\n   */\n  readonly evictionPolicy?: string;\n\n  /**\n   * The billing profile for Spot VMs\n   */\n  readonly billingProfile?: VirtualMachineBillingProfile;\n\n  /**\n   * The diagnostics profile for boot diagnostics\n   */\n  readonly diagnosticsProfile?: VirtualMachineDiagnosticsProfile;\n\n  /**\n   * Reference to an availability set\n   */\n  readonly availabilitySet?: VirtualMachineAvailabilitySetReference;\n\n  /**\n   * Reference to a virtual machine scale set\n   */\n  readonly virtualMachineScaleSet?: VirtualMachineScaleSetReference;\n\n  /**\n   * Reference to a proximity placement group\n   */\n  readonly proximityPlacementGroup?: VirtualMachineProximityPlacementGroupReference;\n\n  /**\n   * Reference to a dedicated host\n   */\n  readonly host?: VirtualMachineHostReference;\n\n  /**\n   * Additional capabilities like Ultra SSD\n   */\n  readonly additionalCapabilities?: VirtualMachineAdditionalCapabilities;\n\n  /**\n   * Security settings for the Virtual Machine\n   */\n  readonly securityProfile?: VirtualMachineSecurityProfile;\n\n  /**\n   * The lifecycle rules to ignore changes\n   * Useful for properties that are externally managed or should not trigger updates\n   * @example [\"osProfile.adminPassword\"]\n   */\n  readonly ignoreChanges?: string[];\n\n  /**\n   * Resource group ID where the Virtual Machine will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * Virtual Machine properties for the request body\n */\nexport interface VirtualMachineBodyProperties {\n  readonly hardwareProfile: VirtualMachineHardwareProfile;\n  readonly storageProfile: VirtualMachineStorageProfile;\n  readonly osProfile?: VirtualMachineOSProfile;\n  readonly networkProfile: VirtualMachineNetworkProfile;\n  readonly diagnosticsProfile?: VirtualMachineDiagnosticsProfile;\n  readonly availabilitySet?: VirtualMachineAvailabilitySetReference;\n  readonly virtualMachineScaleSet?: VirtualMachineScaleSetReference;\n  readonly proximityPlacementGroup?: VirtualMachineProximityPlacementGroupReference;\n  readonly priority?: string;\n  readonly evictionPolicy?: string;\n  readonly billingProfile?: VirtualMachineBillingProfile;\n  readonly host?: VirtualMachineHostReference;\n  readonly licenseType?: VirtualMachineLicenseType;\n  readonly additionalCapabilities?: VirtualMachineAdditionalCapabilities;\n  readonly securityProfile?: VirtualMachineSecurityProfile;\n}\n\n/**\n * The resource body interface for Azure Virtual Machine API calls\n */\nexport interface VirtualMachineBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly identity?: VirtualMachineIdentity;\n  readonly zones?: string[];\n  readonly plan?: VirtualMachinePlan;\n  readonly properties: VirtualMachineBodyProperties;\n}\n\n/**\n * Unified Azure Virtual Machine implementation\n *\n * This class provides a single, version-aware implementation that automatically handles version\n * resolution, schema validation, and property transformation while maintaining full JSII compliance.\n *\n * The class uses the VersionedAzapiResource framework to provide:\n * - Automatic latest version resolution (2025-04-01 as of this implementation)\n * - Support for explicit version pinning when stability is required\n * - Schema-driven property validation and transformation\n * - Migration analysis and deprecation warnings\n * - Full JSII compliance for multi-language support\n *\n * @example\n * // Basic Linux VM with SSH authentication:\n * const vm = new VirtualMachine(this, \"vm\", {\n *   name: \"my-linux-vm\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   hardwareProfile: {\n *     vmSize: \"Standard_D2s_v3\"\n *   },\n *   storageProfile: {\n *     imageReference: {\n *       publisher: \"Canonical\",\n *       offer: \"0001-com-ubuntu-server-jammy\",\n *       sku: \"22_04-lts-gen2\",\n *       version: \"latest\"\n *     },\n *     osDisk: {\n *       createOption: \"FromImage\",\n *       managedDisk: {\n *         storageAccountType: \"Premium_LRS\"\n *       }\n *     }\n *   },\n *   osProfile: {\n *     computerName: \"myvm\",\n *     adminUsername: \"azureuser\",\n *     linuxConfiguration: {\n *       disablePasswordAuthentication: true,\n *       ssh: {\n *         publicKeys: [{\n *           path: \"/home/azureuser/.ssh/authorized_keys\",\n *           keyData: \"ssh-rsa AAAA...\"\n *         }]\n *       }\n *     }\n *   },\n *   networkProfile: {\n *     networkInterfaces: [{\n *       id: networkInterface.id\n *     }]\n *   },\n *   identity: {\n *     type: \"SystemAssigned\"\n *   }\n * });\n *\n * @example\n * // Windows VM with password authentication:\n * const windowsVm = new VirtualMachine(this, \"windows-vm\", {\n *   name: \"my-windows-vm\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   hardwareProfile: {\n *     vmSize: \"Standard_D2s_v3\"\n *   },\n *   storageProfile: {\n *     imageReference: {\n *       publisher: \"MicrosoftWindowsServer\",\n *       offer: \"WindowsServer\",\n *       sku: \"2022-datacenter-azure-edition\",\n *       version: \"latest\"\n *     },\n *     osDisk: {\n *       createOption: \"FromImage\",\n *       managedDisk: {\n *         storageAccountType: \"Premium_LRS\"\n *       }\n *     }\n *   },\n *   osProfile: {\n *     computerName: \"mywinvm\",\n *     adminUsername: \"azureuser\",\n *     adminPassword: \"P@ssw0rd1234!\",\n *     windowsConfiguration: {\n *       provisionVMAgent: true,\n *       enableAutomaticUpdates: true\n *     }\n *   },\n *   networkProfile: {\n *     networkInterfaces: [{\n *       id: networkInterface.id\n *     }]\n *   },\n *   licenseType: \"Windows_Server\"\n * });\n *\n * @stability stable\n */\nexport class VirtualMachine extends AzapiResource {\n  /**\n   * Returns a production-ready monitoring configuration for Virtual Machines\n   *\n   * This static factory method provides a complete MonitoringConfig with sensible defaults\n   * for VM monitoring including CPU, memory, disk queue alerts, and deletion tracking.\n   *\n   * @param actionGroupId - The resource ID of the action group for alert notifications\n   * @param workspaceId - Optional Log Analytics workspace ID for diagnostic settings\n   * @param options - Optional configuration to customize thresholds and enable/disable specific alerts\n   * @returns A complete MonitoringConfig object ready to use in VirtualMachine props\n   *\n   * @example\n   * // Basic usage with all defaults\n   * const vm = new VirtualMachine(this, \"vm\", {\n   *   // ... other properties ...\n   *   monitoring: VirtualMachine.defaultMonitoring(actionGroup.id, workspace.id)\n   * });\n   *\n   * @example\n   * // Custom thresholds\n   * const vm = new VirtualMachine(this, \"vm\", {\n   *   // ... other properties ...\n   *   monitoring: VirtualMachine.defaultMonitoring(\n   *     actionGroup.id,\n   *     workspace.id,\n   *     {\n   *       cpuThreshold: 90,\n   *       memoryThreshold: 536870912, // 512MB\n   *       enableDiskQueueAlert: false\n   *     }\n   *   )\n   * });\n   */\n  public static defaultMonitoring(\n    actionGroupId: string,\n    workspaceId?: string,\n    options?: VirtualMachineMonitoringOptions,\n  ): MonitoringConfig {\n    const metricAlerts: any[] = [];\n\n    // High CPU Alert\n    if (options?.enableCpuAlert !== false) {\n      metricAlerts.push({\n        name: \"high-cpu-alert\",\n        description: \"Alert when CPU usage exceeds threshold\",\n        severity: (options?.cpuAlertSeverity ?? 2) as 0 | 1 | 2 | 3 | 4,\n        scopes: [], // Will be set automatically by base class\n        evaluationFrequency: \"PT5M\",\n        windowSize: \"PT15M\",\n        criteria: {\n          type: \"StaticThreshold\" as const,\n          metricName: \"Percentage CPU\",\n          metricNamespace: \"Microsoft.Compute/virtualMachines\",\n          operator: \"GreaterThan\" as const,\n          threshold: options?.cpuThreshold ?? 80,\n          timeAggregation: \"Average\" as const,\n        },\n        actions: [{ actionGroupId }],\n      });\n    }\n\n    // Low Memory Alert\n    if (options?.enableMemoryAlert !== false) {\n      metricAlerts.push({\n        name: \"low-memory-alert\",\n        description: \"Alert when available memory falls below threshold\",\n        severity: (options?.memoryAlertSeverity ?? 2) as 0 | 1 | 2 | 3 | 4,\n        scopes: [], // Will be set automatically by base class\n        evaluationFrequency: \"PT5M\",\n        windowSize: \"PT15M\",\n        criteria: {\n          type: \"StaticThreshold\" as const,\n          metricName: \"Available Memory Bytes\",\n          metricNamespace: \"Microsoft.Compute/virtualMachines\",\n          operator: \"LessThan\" as const,\n          threshold: options?.memoryThreshold ?? 1073741824,\n          timeAggregation: \"Average\" as const,\n        },\n        actions: [{ actionGroupId }],\n      });\n    }\n\n    // High Disk Queue Alert\n    if (options?.enableDiskQueueAlert !== false) {\n      metricAlerts.push({\n        name: \"high-disk-queue-alert\",\n        description: \"Alert when disk queue depth exceeds threshold\",\n        severity: (options?.diskQueueAlertSeverity ?? 2) as 0 | 1 | 2 | 3 | 4,\n        scopes: [], // Will be set automatically by base class\n        evaluationFrequency: \"PT5M\",\n        windowSize: \"PT15M\",\n        criteria: {\n          type: \"StaticThreshold\" as const,\n          metricName: \"OS Disk Queue Depth\",\n          metricNamespace: \"Microsoft.Compute/virtualMachines\",\n          operator: \"GreaterThan\" as const,\n          threshold: options?.diskQueueThreshold ?? 32,\n          timeAggregation: \"Average\" as const,\n        },\n        actions: [{ actionGroupId }],\n      });\n    }\n\n    // Build diagnostic settings if workspace ID is provided\n    const diagnosticSettings = workspaceId\n      ? {\n          name: \"vm-diagnostics\",\n          targetResourceId: \"\", // Will be set automatically by base class\n          workspaceId: workspaceId,\n          logs: [{ categoryGroup: \"allLogs\", enabled: true }],\n          metrics: [{ category: \"AllMetrics\", enabled: true }],\n        }\n      : undefined;\n\n    // Build activity log alerts\n    const activityLogAlerts =\n      options?.enableDeletionAlert !== false\n        ? [\n            {\n              name: \"vm-deletion-alert\",\n              description: \"Alert when virtual machine is deleted\",\n              scopes: [], // Will be set automatically by base class\n              condition: {\n                allOf: [\n                  {\n                    field: \"operationName\",\n                    equalsValue: \"Microsoft.Compute/virtualMachines/delete\",\n                  },\n                ],\n              },\n              actions: {\n                actionGroups: [{ actionGroupId }],\n              },\n            },\n          ]\n        : undefined;\n\n    // Return complete config object\n    return {\n      enabled: true,\n      diagnosticSettings: diagnosticSettings,\n      metricAlerts: metricAlerts,\n      activityLogAlerts: activityLogAlerts,\n    };\n  }\n\n  /**\n   * Static initialization flag to ensure schemas are registered only once\n   */\n  private static schemasRegistered = false;\n\n  /**\n   * Ensures that Virtual Machine schemas are registered with the ApiVersionManager\n   * This is called once during the first VirtualMachine instantiation\n   */\n  private static ensureSchemasRegistered(): void {\n    if (VirtualMachine.schemasRegistered) {\n      return;\n    }\n\n    const apiVersionManager = ApiVersionManager.instance();\n\n    try {\n      // Register all Virtual Machine versions\n      apiVersionManager.registerResourceType(\n        VIRTUAL_MACHINE_TYPE,\n        ALL_VIRTUAL_MACHINE_VERSIONS,\n      );\n\n      VirtualMachine.schemasRegistered = true;\n\n      console.log(\n        `Registered ${ALL_VIRTUAL_MACHINE_VERSIONS.length} API versions for ${VIRTUAL_MACHINE_TYPE}`,\n      );\n    } catch (error) {\n      console.warn(\n        `Failed to register Virtual Machine schemas: ${error}. ` +\n          `This may indicate the schemas are already registered or there's a configuration issue.`,\n      );\n      // Don't throw here as the schemas might already be registered\n      VirtualMachine.schemasRegistered = true;\n    }\n  }\n\n  /**\n   * The input properties for this Virtual Machine instance\n   */\n  public readonly props: VirtualMachineProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly locationOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly tagsOutput: cdktf.TerraformOutput;\n  public readonly vmIdOutput: cdktf.TerraformOutput;\n\n  // Public properties that match common VM interface patterns\n  public readonly id: string;\n  public readonly tags: { [key: string]: string };\n\n  /**\n   * Creates a new Azure Virtual Machine using the VersionedAzapiResource framework\n   *\n   * The constructor automatically handles version resolution, schema registration,\n   * validation, and resource creation.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the Virtual Machine\n   */\n  constructor(scope: Construct, id: string, props: VirtualMachineProps) {\n    // Ensure schemas are registered before calling super\n    VirtualMachine.ensureSchemasRegistered();\n\n    // Call the parent constructor with the props\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\n    this.id = `\\${${this.terraformResource.fqn}.id}`;\n    this.tags = props.tags || {};\n\n    // Create Terraform outputs for easy access and referencing from other resources\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Virtual Machine\",\n    });\n\n    this.locationOutput = new cdktf.TerraformOutput(this, \"location\", {\n      value: `\\${${this.terraformResource.fqn}.location}`,\n      description: \"The location of the Virtual Machine\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Virtual Machine\",\n    });\n\n    this.tagsOutput = new cdktf.TerraformOutput(this, \"tags\", {\n      value: `\\${${this.terraformResource.fqn}.tags}`,\n      description: \"The tags assigned to the Virtual Machine\",\n    });\n\n    this.vmIdOutput = new cdktf.TerraformOutput(this, \"vmId\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.vmId}`,\n      description: \"The unique identifier of the Virtual Machine\",\n    });\n\n    // Override logical IDs to match naming convention\n    this.idOutput.overrideLogicalId(\"id\");\n    this.locationOutput.overrideLogicalId(\"location\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.tagsOutput.overrideLogicalId(\"tags\");\n    this.vmIdOutput.overrideLogicalId(\"vmId\");\n\n    // Apply ignore changes if specified\n    this._applyIgnoreChanges();\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   * Returns the most recent stable version as the default\n   */\n  protected defaultVersion(): string {\n    return \"2025-04-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Virtual Machines\n   */\n  protected resourceType(): string {\n    return VIRTUAL_MACHINE_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   * Uses the framework's schema resolution to get the appropriate schema\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   * Transforms the input properties into the JSON format expected by Azure REST API\n   */\n  protected createResourceBody(props: any): any {\n    const typedProps = props as VirtualMachineProps;\n    return {\n      location: typedProps.location || \"eastus\",\n      tags: typedProps.tags || {},\n      identity: typedProps.identity,\n      zones: typedProps.zones,\n      plan: typedProps.plan,\n      properties: {\n        hardwareProfile: typedProps.hardwareProfile,\n        storageProfile: typedProps.storageProfile,\n        osProfile: typedProps.osProfile,\n        networkProfile: typedProps.networkProfile,\n        diagnosticsProfile: typedProps.diagnosticsProfile,\n        availabilitySet: typedProps.availabilitySet,\n        virtualMachineScaleSet: typedProps.virtualMachineScaleSet,\n        proximityPlacementGroup: typedProps.proximityPlacementGroup,\n        priority: typedProps.priority,\n        evictionPolicy: typedProps.evictionPolicy,\n        billingProfile: typedProps.billingProfile,\n        host: typedProps.host,\n        licenseType: typedProps.licenseType,\n        additionalCapabilities: typedProps.additionalCapabilities,\n        securityProfile: typedProps.securityProfile,\n      },\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR VIRTUAL MACHINE OPERATIONS\n  // =============================================================================\n\n  /**\n   * Get the VM ID (unique identifier assigned by Azure)\n   */\n  public get vmId(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.vmId}`;\n  }\n\n  /**\n   * Get the provisioning state of the Virtual Machine\n   */\n  public get provisioningState(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.provisioningState}`;\n  }\n\n  /**\n   * Get the OS profile computer name\n   */\n  public get computerName(): string | undefined {\n    return this.props.osProfile?.computerName;\n  }\n\n  /**\n   * Get the VM size\n   */\n  public get vmSize(): string {\n    return this.props.hardwareProfile.vmSize;\n  }\n\n  /**\n   * Add a tag to the Virtual Machine\n   * Note: This modifies the construct props but requires a new deployment to take effect\n   */\n  public addTag(key: string, value: string): void {\n    if (!this.props.tags) {\n      (this.props as any).tags = {};\n    }\n    this.props.tags![key] = value;\n  }\n\n  /**\n   * Remove a tag from the Virtual Machine\n   * Note: This modifies the construct props but requires a new deployment to take effect\n   */\n  public removeTag(key: string): void {\n    if (this.props.tags && this.props.tags[key]) {\n      delete this.props.tags[key];\n    }\n  }\n\n  // =============================================================================\n  // PRIVATE HELPER METHODS\n  // =============================================================================\n\n  /**\n   * Applies ignore changes lifecycle rules if specified in props\n   */\n  private _applyIgnoreChanges(): void {\n    if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {\n      // Common properties that are safe to ignore for Virtual Machines\n      // adminPassword should often be ignored to prevent drift\n      const validIgnoreChanges = this.props.ignoreChanges.filter(\n        (change) => change !== \"name\", // name cannot be changed after creation\n      );\n\n      if (validIgnoreChanges.length > 0) {\n        this.terraformResource.addOverride(\"lifecycle\", {\n          ignore_changes: validIgnoreChanges,\n        });\n      }\n    }\n  }\n}\n"]}

package/lib/azure-virtualmachine/test/virtual-machine.integ.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration test for Azure Virtual Machine
+ *
+ * This test demonstrates comprehensive usage of the VirtualMachine construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktf/lib/testing/adapters/jest";