@microsoft/terraform-cdk-constructs 1.0.0 → 1.3.0

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

@@ -0,0 +1,466 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AksCluster = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Kubernetes Service (AKS) implementation using VersionedAzapiResource framework
+ *
+ * This class provides a single, version-aware implementation for AKS clusters that automatically
+ * handles version management, schema validation, and property transformation across all supported
+ * API versions.
+ *
+ * Supported API Versions:
+ * - 2024-10-01 (Active)
+ * - 2025-01-01 (Active)
+ * - 2025-07-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 AKS features (networking, security, scaling, etc.)
+ */
+const cdktf = require("cdktf");
+const aks_cluster_schemas_1 = require("./aks-cluster-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+const resource_action_1 = require("../../core-azure/lib/azapi/providers-azapi/resource-action");
+/**
+ * Unified Azure Kubernetes Service cluster 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-07-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 AKS cluster with system node pool:
+ * const aksCluster = new AksCluster(this, "aks", {
+ *   name: "my-aks-cluster",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   dnsPrefix: "myaks",
+ *   agentPoolProfiles: [{
+ *     name: "system",
+ *     count: 3,
+ *     vmSize: "Standard_D2s_v3",
+ *     mode: "System"
+ *   }],
+ *   identity: {
+ *     type: "SystemAssigned"
+ *   }
+ * });
+ *
+ * @example
+ * // AKS cluster with explicit version pinning and advanced networking:
+ * const aksCluster = new AksCluster(this, "aks", {
+ *   name: "my-aks-cluster",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   apiVersion: "2025-07-01",
+ *   dnsPrefix: "myaks",
+ *   kubernetesVersion: "1.28.3",
+ *   agentPoolProfiles: [{
+ *     name: "system",
+ *     count: 3,
+ *     vmSize: "Standard_D2s_v3",
+ *     mode: "System",
+ *     vnetSubnetID: subnet.id
+ *   }],
+ *   identity: {
+ *     type: "SystemAssigned"
+ *   },
+ *   networkProfile: {
+ *     networkPlugin: "azure",
+ *     serviceCidr: "10.0.0.0/16",
+ *     dnsServiceIP: "10.0.0.10"
+ *   },
+ *   enableRBAC: true
+ * });
+ *
+ * @stability stable
+ */
+class AksCluster extends azapi_resource_1.AzapiResource {
+    /**
+     * Returns a production-ready monitoring configuration for AKS Clusters
+     *
+     * This static factory method provides a complete MonitoringConfig with sensible defaults
+     * for AKS monitoring including node CPU, node memory, failed pod 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 AksCluster props
+     *
+     * @example
+     * // Basic usage with all defaults
+     * const aksCluster = new AksCluster(this, "aks", {
+     *   // ... other properties ...
+     *   monitoring: AksCluster.defaultMonitoring(actionGroup.id, workspace.id)
+     * });
+     *
+     * @example
+     * // Custom thresholds and severities
+     * const aksCluster = new AksCluster(this, "aks", {
+     *   // ... other properties ...
+     *   monitoring: AksCluster.defaultMonitoring(
+     *     actionGroup.id,
+     *     workspace.id,
+     *     {
+     *       nodeCpuThreshold: 90,
+     *       nodeMemoryThreshold: 90,
+     *       enableFailedPodAlert: false
+     *     }
+     *   )
+     * });
+     *
+     * @stability stable
+     */
+    static defaultMonitoring(actionGroupId, workspaceId, options) {
+        const metricAlerts = [];
+        // High Node CPU Alert
+        if (options?.enableNodeCpuAlert !== false) {
+            metricAlerts.push({
+                name: "high-node-cpu-alert",
+                description: "Alert when AKS node CPU usage exceeds threshold",
+                severity: (options?.nodeCpuAlertSeverity ?? 2),
+                scopes: [], // Will be set automatically by base class
+                evaluationFrequency: "PT5M",
+                windowSize: "PT15M",
+                criteria: {
+                    type: "StaticThreshold",
+                    metricName: "node_cpu_usage_percentage",
+                    metricNamespace: "Microsoft.ContainerService/managedClusters",
+                    operator: "GreaterThan",
+                    threshold: options?.nodeCpuThreshold ?? 80,
+                    timeAggregation: "Average",
+                },
+                actions: [{ actionGroupId }],
+            });
+        }
+        // High Node Memory Alert
+        if (options?.enableNodeMemoryAlert !== false) {
+            metricAlerts.push({
+                name: "high-node-memory-alert",
+                description: "Alert when AKS node memory usage exceeds threshold",
+                severity: (options?.nodeMemoryAlertSeverity ?? 2),
+                scopes: [], // Will be set automatically by base class
+                evaluationFrequency: "PT5M",
+                windowSize: "PT15M",
+                criteria: {
+                    type: "StaticThreshold",
+                    metricName: "node_memory_working_set_percentage",
+                    metricNamespace: "Microsoft.ContainerService/managedClusters",
+                    operator: "GreaterThan",
+                    threshold: options?.nodeMemoryThreshold ?? 80,
+                    timeAggregation: "Average",
+                },
+                actions: [{ actionGroupId }],
+            });
+        }
+        // Failed Pods Alert
+        if (options?.enableFailedPodAlert !== false) {
+            metricAlerts.push({
+                name: "failed-pods-alert",
+                description: "Alert when pods are in failed state",
+                severity: (options?.failedPodAlertSeverity ?? 1),
+                scopes: [], // Will be set automatically by base class
+                evaluationFrequency: "PT5M",
+                windowSize: "PT15M",
+                criteria: {
+                    type: "StaticThreshold",
+                    metricName: "kube_pod_status_phase",
+                    metricNamespace: "Microsoft.ContainerService/managedClusters",
+                    operator: "GreaterThan",
+                    threshold: options?.failedPodThreshold ?? 0,
+                    timeAggregation: "Average",
+                    dimensions: [
+                        {
+                            name: "phase",
+                            operator: "Include",
+                            values: ["Failed"],
+                        },
+                    ],
+                },
+                actions: [{ actionGroupId }],
+            });
+        }
+        // Build diagnostic settings if workspace ID is provided
+        const diagnosticSettings = workspaceId
+            ? {
+                name: "aks-cluster-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: "aks-cluster-deletion-alert",
+                    description: "Alert when AKS cluster is deleted",
+                    scopes: [], // Will be set automatically by base class
+                    condition: {
+                        allOf: [
+                            {
+                                field: "operationName",
+                                equalsValue: "Microsoft.ContainerService/managedClusters/delete",
+                            },
+                        ],
+                    },
+                    actions: {
+                        actionGroups: [{ actionGroupId }],
+                    },
+                },
+            ]
+            : undefined;
+        // Return complete config object
+        return {
+            enabled: true,
+            diagnosticSettings: diagnosticSettings,
+            metricAlerts: metricAlerts,
+            activityLogAlerts: activityLogAlerts,
+        };
+    }
+    /**
+     * Creates a new Azure Kubernetes Service cluster 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 AKS cluster
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        // Extract properties from the AZAPI resource outputs using Terraform interpolation
+        // Create resource action to retrieve cluster admin credentials
+        this.credentialAction = new resource_action_1.ResourceAction(this, "listCredentials", {
+            type: `${aks_cluster_schemas_1.AKS_CLUSTER_TYPE}@${this.resolvedApiVersion}`,
+            resourceId: this.id,
+            action: "listClusterAdminCredential",
+            method: "POST",
+            responseExportValues: ["*"],
+        });
+        // 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 AKS Cluster",
+        });
+        this.locationOutput = new cdktf.TerraformOutput(this, "location", {
+            value: `\${${this.terraformResource.fqn}.location}`,
+            description: "The location of the AKS Cluster",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the AKS Cluster",
+        });
+        this.tagsOutput = new cdktf.TerraformOutput(this, "tags", {
+            value: `\${${this.terraformResource.fqn}.tags}`,
+            description: "The tags assigned to the AKS Cluster",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the AKS Cluster",
+        });
+        // Override logical IDs to match naming convention
+        this.idOutput.overrideLogicalId("id");
+        this.locationOutput.overrideLogicalId("location");
+        this.nameOutput.overrideLogicalId("name");
+        this.tagsOutput.overrideLogicalId("tags");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+        // Apply ignore changes if specified
+        this._applyIgnoreChanges();
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Indicates that this resource requires a location
+     */
+    requiresLocation() {
+        return true;
+    }
+    /**
+     * 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-07-01";
+    }
+    /**
+     * Gets the Azure resource type for AKS Clusters
+     */
+    resourceType() {
+        return aks_cluster_schemas_1.AKS_CLUSTER_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: this.location,
+            tags: this.allTags(),
+            sku: typedProps.sku,
+            identity: typedProps.identity,
+            properties: {
+                kubernetesVersion: typedProps.kubernetesVersion,
+                dnsPrefix: typedProps.dnsPrefix,
+                fqdn: typedProps.fqdn,
+                privateFQDN: typedProps.privateFQDN,
+                agentPoolProfiles: typedProps.agentPoolProfiles,
+                servicePrincipalProfile: typedProps.servicePrincipalProfile,
+                networkProfile: typedProps.networkProfile,
+                aadProfile: typedProps.aadProfile,
+                autoScalerProfile: this._transformAutoScalerProfile(typedProps.autoScalerProfile),
+                apiServerAccessProfile: typedProps.apiServerAccessProfile,
+                diskEncryptionSetID: typedProps.diskEncryptionSetID,
+                enableRBAC: typedProps.enableRBAC !== undefined ? typedProps.enableRBAC : true,
+                nodeResourceGroup: typedProps.nodeResourceGroup,
+                addonProfiles: typedProps.addonProfiles,
+                linuxProfile: typedProps.linuxProfile,
+                windowsProfile: typedProps.windowsProfile,
+                oidcIssuerProfile: typedProps.oidcIssuerProfile,
+                securityProfile: typedProps.securityProfile,
+                storageProfile: typedProps.storageProfile,
+                httpProxyConfig: typedProps.httpProxyConfig,
+                workloadAutoScalerProfile: typedProps.workloadAutoScalerProfile,
+                disableLocalAccounts: typedProps.disableLocalAccounts,
+                publicNetworkAccess: typedProps.publicNetworkAccess,
+                supportPlan: typedProps.supportPlan,
+            },
+        };
+    }
+    // =============================================================================
+    // PUBLIC METHODS FOR AKS CLUSTER OPERATIONS
+    // =============================================================================
+    /**
+     * Get the FQDN of the cluster
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+    /**
+     * Get the private FQDN of the cluster (if private cluster is enabled)
+     */
+    get privateFqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.privateFQDN}`;
+    }
+    /**
+     * Get the Kubernetes configuration for the cluster
+     *
+     * This retrieves the cluster admin credentials using an azapi_resource_action.
+     * The kubeConfig is base64 encoded and contains the full kubectl configuration.
+     */
+    get kubeConfig() {
+        // Access the kubeConfig from the credential action's output
+        // The output structure is: { kubeConfigs: [{ value: "base64-encoded-config" }] }
+        return `\${${this.credentialAction.fqn}.output.kubeConfigs[0].value}`;
+    }
+    /**
+     * Get the current Kubernetes version running on the cluster
+     */
+    get currentKubernetesVersion() {
+        return `\${${this.terraformResource.fqn}.output.properties.currentKubernetesVersion}`;
+    }
+    /**
+     * Get the node resource group name
+     */
+    get nodeResourceGroupName() {
+        return `\${${this.terraformResource.fqn}.output.properties.nodeResourceGroup}`;
+    }
+    /**
+     * Add a tag to the AKS Cluster
+     * 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 AKS Cluster
+     * 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
+    // =============================================================================
+    /**
+     * Transforms autoScalerProfile properties from camelCase to kebab-case
+     * The Azure AKS API requires kebab-case for autoScalerProfile properties
+     */
+    _transformAutoScalerProfile(profile) {
+        if (!profile) {
+            return undefined;
+        }
+        return {
+            "balance-similar-node-groups": profile.balanceSimilarNodeGroups,
+            expander: profile.expander,
+            "max-empty-bulk-delete": profile.maxEmptyBulkDelete,
+            "max-graceful-termination-sec": profile.maxGracefulTerminationSec,
+            "max-node-provision-time": profile.maxNodeProvisionTime,
+            "max-total-unready-percentage": profile.maxTotalUnreadyPercentage,
+            "new-pod-scale-up-delay": profile.newPodScaleUpDelay,
+            "ok-total-unready-count": profile.okTotalUnreadyCount,
+            "scan-interval": profile.scanInterval,
+            "scale-down-delay-after-add": profile.scaleDownDelayAfterAdd,
+            "scale-down-delay-after-delete": profile.scaleDownDelayAfterDelete,
+            "scale-down-delay-after-failure": profile.scaleDownDelayAfterFailure,
+            "scale-down-unneeded-time": profile.scaleDownUnneededTime,
+            "scale-down-unready-time": profile.scaleDownUnreadyTime,
+            "scale-down-utilization-threshold": profile.scaleDownUtilizationThreshold,
+            "skip-nodes-with-local-storage": profile.skipNodesWithLocalStorage,
+            "skip-nodes-with-system-pods": profile.skipNodesWithSystemPods,
+        };
+    }
+    /**
+     * 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 AKS clusters
+            // kubernetesVersion changes frequently during upgrades
+            // agentPoolProfiles can be managed separately
+            const validIgnoreChanges = this.props.ignoreChanges.filter((change) => change !== "dnsPrefix");
+            if (validIgnoreChanges.length > 0) {
+                this.terraformResource.addOverride("lifecycle", [
+                    {
+                        ignore_changes: validIgnoreChanges,
+                    },
+                ]);
+            }
+        }
+    }
+}
+exports.AksCluster = AksCluster;
+_a = JSII_RTTI_SYMBOL_1;
+AksCluster[_a] = { fqn: "@microsoft/terraform-cdk-constructs.AksCluster", version: "1.3.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(aks_cluster_schemas_1.AKS_CLUSTER_TYPE, aks_cluster_schemas_1.ALL_AKS_CLUSTER_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aks-cluster.js","sourceRoot":"","sources":["../../../src/azure-aks/lib/aks-cluster.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Kubernetes Service (AKS) implementation using VersionedAzapiResource framework\n *\n * This class provides a single, version-aware implementation for AKS clusters that automatically\n * handles version management, schema validation, and property transformation across all supported\n * API versions.\n *\n * Supported API Versions:\n * - 2024-10-01 (Active)\n * - 2025-01-01 (Active)\n * - 2025-07-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 AKS features (networking, security, scaling, etc.)\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_AKS_CLUSTER_VERSIONS,\n  AKS_CLUSTER_TYPE,\n  AksClusterSku,\n  AksClusterIdentity,\n  AksClusterAgentPoolProfile,\n  AksClusterNetworkProfile,\n  AksClusterServicePrincipalProfile,\n  AksClusterApiServerAccessProfile,\n  AksClusterAutoScalerProfile,\n  AksClusterWindowsProfile,\n  AksClusterLinuxProfile,\n  AksClusterAadProfile,\n  AksClusterAddonProfiles,\n  AksClusterOidcIssuerProfile,\n  AksClusterSecurityProfile,\n  AksClusterStorageProfile,\n  AksClusterHttpProxyConfig,\n  AksClusterWorkloadAutoScalerProfile,\n  AksClusterMonitoringOptions,\n} from \"./aks-cluster-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n  MonitoringConfig,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ResourceAction } from \"../../core-azure/lib/azapi/providers-azapi/resource-action\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Properties for the unified Azure Kubernetes Service cluster\n *\n * Extends AzapiResourceProps with AKS-specific properties\n */\nexport interface AksClusterProps extends AzapiResourceProps {\n  /**\n   * The SKU (pricing tier) for the AKS cluster\n   * @example { name: \"Base\", tier: \"Free\" }\n   * @example { name: \"Standard\", tier: \"Standard\" }\n   */\n  readonly sku?: AksClusterSku;\n\n  /**\n   * The identity configuration for the AKS cluster\n   * @example { type: \"SystemAssigned\" }\n   * @example { type: \"UserAssigned\", userAssignedIdentities: { \"/subscriptions/.../resourceGroups/.../providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentity\": {} } }\n   */\n  readonly identity?: AksClusterIdentity;\n\n  /**\n   * The Kubernetes version for the cluster\n   * @example \"1.28.3\"\n   * @example \"1.29.0\"\n   */\n  readonly kubernetesVersion?: string;\n\n  /**\n   * DNS prefix for the cluster\n   * @example \"myakscluster\"\n   */\n  readonly dnsPrefix: string;\n\n  /**\n   * The FQDN for the cluster (read-only)\n   */\n  readonly fqdn?: string;\n\n  /**\n   * The private FQDN for the cluster (read-only)\n   */\n  readonly privateFQDN?: string;\n\n  /**\n   * The agent pool profiles for the cluster node pools\n   * At least one agent pool is required\n   * @example [{ name: \"default\", count: 3, vmSize: \"Standard_D2s_v3\", mode: \"System\" }]\n   */\n  readonly agentPoolProfiles: AksClusterAgentPoolProfile[];\n\n  /**\n   * The service principal profile for the cluster\n   */\n  readonly servicePrincipalProfile?: AksClusterServicePrincipalProfile;\n\n  /**\n   * The network configuration for the cluster\n   */\n  readonly networkProfile?: AksClusterNetworkProfile;\n\n  /**\n   * The Azure Active Directory integration configuration\n   */\n  readonly aadProfile?: AksClusterAadProfile;\n\n  /**\n   * The auto-scaler configuration for the cluster\n   */\n  readonly autoScalerProfile?: AksClusterAutoScalerProfile;\n\n  /**\n   * The API server access configuration\n   */\n  readonly apiServerAccessProfile?: AksClusterApiServerAccessProfile;\n\n  /**\n   * The resource ID of the disk encryption set for encrypting disks\n   */\n  readonly diskEncryptionSetID?: string;\n\n  /**\n   * Whether to enable Kubernetes Role-Based Access Control\n   * @default true\n   */\n  readonly enableRBAC?: boolean;\n\n  /**\n   * The name of the resource group for cluster nodes\n   * If not specified, Azure will auto-generate the name\n   */\n  readonly nodeResourceGroup?: string;\n\n  /**\n   * The addon profiles for cluster addons\n   */\n  readonly addonProfiles?: AksClusterAddonProfiles;\n\n  /**\n   * The Linux profile for SSH access\n   */\n  readonly linuxProfile?: AksClusterLinuxProfile;\n\n  /**\n   * The Windows profile for Windows node pools\n   */\n  readonly windowsProfile?: AksClusterWindowsProfile;\n\n  /**\n   * The OIDC issuer profile for workload identity\n   */\n  readonly oidcIssuerProfile?: AksClusterOidcIssuerProfile;\n\n  /**\n   * The security profile for the cluster\n   */\n  readonly securityProfile?: AksClusterSecurityProfile;\n\n  /**\n   * The storage profile for CSI drivers\n   */\n  readonly storageProfile?: AksClusterStorageProfile;\n\n  /**\n   * The HTTP proxy configuration\n   */\n  readonly httpProxyConfig?: AksClusterHttpProxyConfig;\n\n  /**\n   * The workload auto-scaler profile\n   */\n  readonly workloadAutoScalerProfile?: AksClusterWorkloadAutoScalerProfile;\n\n  /**\n   * Whether to disable local accounts\n   * @default false\n   */\n  readonly disableLocalAccounts?: boolean;\n\n  /**\n   * Whether the cluster is accessible from the public internet\n   * @example \"Enabled\"\n   * @example \"Disabled\"\n   */\n  readonly publicNetworkAccess?: string;\n\n  /**\n   * The support plan for the cluster\n   * @example \"KubernetesOfficial\"\n   * @example \"AKSLongTermSupport\"\n   */\n  readonly supportPlan?: string;\n\n  /**\n   * The lifecycle rules to ignore changes\n   * Useful for properties that are externally managed or should not trigger updates\n   * @example [\"kubernetesVersion\", \"agentPoolProfiles\"]\n   */\n  readonly ignoreChanges?: string[];\n\n  /**\n   * Resource group ID where the AKS cluster will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * The resource body interface for Azure AKS API calls\n */\nexport interface AksClusterBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly sku?: AksClusterSku;\n  readonly identity?: AksClusterIdentity;\n  readonly properties: AksClusterBodyProperties;\n}\n\n/**\n * AKS Cluster properties for the request body\n */\nexport interface AksClusterBodyProperties {\n  readonly kubernetesVersion?: string;\n  readonly dnsPrefix: string;\n  readonly fqdn?: string;\n  readonly privateFQDN?: string;\n  readonly agentPoolProfiles: AksClusterAgentPoolProfile[];\n  readonly servicePrincipalProfile?: AksClusterServicePrincipalProfile;\n  readonly networkProfile?: AksClusterNetworkProfile;\n  readonly aadProfile?: AksClusterAadProfile;\n  readonly autoScalerProfile?: AksClusterAutoScalerProfile;\n  readonly apiServerAccessProfile?: AksClusterApiServerAccessProfile;\n  readonly diskEncryptionSetID?: string;\n  readonly enableRBAC?: boolean;\n  readonly nodeResourceGroup?: string;\n  readonly addonProfiles?: AksClusterAddonProfiles;\n  readonly linuxProfile?: AksClusterLinuxProfile;\n  readonly windowsProfile?: AksClusterWindowsProfile;\n  readonly oidcIssuerProfile?: AksClusterOidcIssuerProfile;\n  readonly securityProfile?: AksClusterSecurityProfile;\n  readonly storageProfile?: AksClusterStorageProfile;\n  readonly httpProxyConfig?: AksClusterHttpProxyConfig;\n  readonly workloadAutoScalerProfile?: AksClusterWorkloadAutoScalerProfile;\n  readonly disableLocalAccounts?: boolean;\n  readonly publicNetworkAccess?: string;\n  readonly supportPlan?: string;\n}\n\n/**\n * Unified Azure Kubernetes Service cluster 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-07-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 AKS cluster with system node pool:\n * const aksCluster = new AksCluster(this, \"aks\", {\n *   name: \"my-aks-cluster\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   dnsPrefix: \"myaks\",\n *   agentPoolProfiles: [{\n *     name: \"system\",\n *     count: 3,\n *     vmSize: \"Standard_D2s_v3\",\n *     mode: \"System\"\n *   }],\n *   identity: {\n *     type: \"SystemAssigned\"\n *   }\n * });\n *\n * @example\n * // AKS cluster with explicit version pinning and advanced networking:\n * const aksCluster = new AksCluster(this, \"aks\", {\n *   name: \"my-aks-cluster\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   apiVersion: \"2025-07-01\",\n *   dnsPrefix: \"myaks\",\n *   kubernetesVersion: \"1.28.3\",\n *   agentPoolProfiles: [{\n *     name: \"system\",\n *     count: 3,\n *     vmSize: \"Standard_D2s_v3\",\n *     mode: \"System\",\n *     vnetSubnetID: subnet.id\n *   }],\n *   identity: {\n *     type: \"SystemAssigned\"\n *   },\n *   networkProfile: {\n *     networkPlugin: \"azure\",\n *     serviceCidr: \"10.0.0.0/16\",\n *     dnsServiceIP: \"10.0.0.10\"\n *   },\n *   enableRBAC: true\n * });\n *\n * @stability stable\n */\nexport class AksCluster extends AzapiResource {\n  /**\n   * Returns a production-ready monitoring configuration for AKS Clusters\n   *\n   * This static factory method provides a complete MonitoringConfig with sensible defaults\n   * for AKS monitoring including node CPU, node memory, failed pod 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 AksCluster props\n   *\n   * @example\n   * // Basic usage with all defaults\n   * const aksCluster = new AksCluster(this, \"aks\", {\n   *   // ... other properties ...\n   *   monitoring: AksCluster.defaultMonitoring(actionGroup.id, workspace.id)\n   * });\n   *\n   * @example\n   * // Custom thresholds and severities\n   * const aksCluster = new AksCluster(this, \"aks\", {\n   *   // ... other properties ...\n   *   monitoring: AksCluster.defaultMonitoring(\n   *     actionGroup.id,\n   *     workspace.id,\n   *     {\n   *       nodeCpuThreshold: 90,\n   *       nodeMemoryThreshold: 90,\n   *       enableFailedPodAlert: false\n   *     }\n   *   )\n   * });\n   *\n   * @stability stable\n   */\n  public static defaultMonitoring(\n    actionGroupId: string,\n    workspaceId?: string,\n    options?: AksClusterMonitoringOptions,\n  ): MonitoringConfig {\n    const metricAlerts: any[] = [];\n\n    // High Node CPU Alert\n    if (options?.enableNodeCpuAlert !== false) {\n      metricAlerts.push({\n        name: \"high-node-cpu-alert\",\n        description: \"Alert when AKS node CPU usage exceeds threshold\",\n        severity: (options?.nodeCpuAlertSeverity ?? 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: \"node_cpu_usage_percentage\",\n          metricNamespace: \"Microsoft.ContainerService/managedClusters\",\n          operator: \"GreaterThan\" as const,\n          threshold: options?.nodeCpuThreshold ?? 80,\n          timeAggregation: \"Average\" as const,\n        },\n        actions: [{ actionGroupId }],\n      });\n    }\n\n    // High Node Memory Alert\n    if (options?.enableNodeMemoryAlert !== false) {\n      metricAlerts.push({\n        name: \"high-node-memory-alert\",\n        description: \"Alert when AKS node memory usage exceeds threshold\",\n        severity: (options?.nodeMemoryAlertSeverity ?? 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: \"node_memory_working_set_percentage\",\n          metricNamespace: \"Microsoft.ContainerService/managedClusters\",\n          operator: \"GreaterThan\" as const,\n          threshold: options?.nodeMemoryThreshold ?? 80,\n          timeAggregation: \"Average\" as const,\n        },\n        actions: [{ actionGroupId }],\n      });\n    }\n\n    // Failed Pods Alert\n    if (options?.enableFailedPodAlert !== false) {\n      metricAlerts.push({\n        name: \"failed-pods-alert\",\n        description: \"Alert when pods are in failed state\",\n        severity: (options?.failedPodAlertSeverity ?? 1) 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: \"kube_pod_status_phase\",\n          metricNamespace: \"Microsoft.ContainerService/managedClusters\",\n          operator: \"GreaterThan\" as const,\n          threshold: options?.failedPodThreshold ?? 0,\n          timeAggregation: \"Average\" as const,\n          dimensions: [\n            {\n              name: \"phase\" as const,\n              operator: \"Include\" as const,\n              values: [\"Failed\"],\n            },\n          ],\n        },\n        actions: [{ actionGroupId }],\n      });\n    }\n\n    // Build diagnostic settings if workspace ID is provided\n    const diagnosticSettings = workspaceId\n      ? {\n          name: \"aks-cluster-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: \"aks-cluster-deletion-alert\",\n              description: \"Alert when AKS cluster is deleted\",\n              scopes: [], // Will be set automatically by base class\n              condition: {\n                allOf: [\n                  {\n                    field: \"operationName\",\n                    equalsValue:\n                      \"Microsoft.ContainerService/managedClusters/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  static {\n    AzapiResource.registerSchemas(AKS_CLUSTER_TYPE, ALL_AKS_CLUSTER_VERSIONS);\n  }\n\n  /**\n   * The input properties for this AKS Cluster instance\n   */\n  public readonly props: AksClusterProps;\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 fqdnOutput: cdktf.TerraformOutput;\n\n  // Public properties that match common AKS interface patterns\n\n  // Resource action for retrieving cluster credentials\n  private readonly credentialAction: ResourceAction;\n\n  /**\n   * Creates a new Azure Kubernetes Service cluster 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 AKS cluster\n   */\n  constructor(scope: Construct, id: string, props: AksClusterProps) {\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\n\n    // Create resource action to retrieve cluster admin credentials\n    this.credentialAction = new ResourceAction(this, \"listCredentials\", {\n      type: `${AKS_CLUSTER_TYPE}@${this.resolvedApiVersion}`,\n      resourceId: this.id,\n      action: \"listClusterAdminCredential\",\n      method: \"POST\",\n      responseExportValues: [\"*\"],\n    });\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 AKS Cluster\",\n    });\n\n    this.locationOutput = new cdktf.TerraformOutput(this, \"location\", {\n      value: `\\${${this.terraformResource.fqn}.location}`,\n      description: \"The location of the AKS Cluster\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the AKS Cluster\",\n    });\n\n    this.tagsOutput = new cdktf.TerraformOutput(this, \"tags\", {\n      value: `\\${${this.terraformResource.fqn}.tags}`,\n      description: \"The tags assigned to the AKS Cluster\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the AKS Cluster\",\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.fqdnOutput.overrideLogicalId(\"fqdn\");\n\n    // Apply ignore changes if specified\n    this._applyIgnoreChanges();\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Indicates that this resource requires a location\n   */\n  protected requiresLocation(): boolean {\n    return true;\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-07-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for AKS Clusters\n   */\n  protected resourceType(): string {\n    return AKS_CLUSTER_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 AksClusterProps;\n    return {\n      location: this.location,\n      tags: this.allTags(),\n      sku: typedProps.sku,\n      identity: typedProps.identity,\n      properties: {\n        kubernetesVersion: typedProps.kubernetesVersion,\n        dnsPrefix: typedProps.dnsPrefix,\n        fqdn: typedProps.fqdn,\n        privateFQDN: typedProps.privateFQDN,\n        agentPoolProfiles: typedProps.agentPoolProfiles,\n        servicePrincipalProfile: typedProps.servicePrincipalProfile,\n        networkProfile: typedProps.networkProfile,\n        aadProfile: typedProps.aadProfile,\n        autoScalerProfile: this._transformAutoScalerProfile(\n          typedProps.autoScalerProfile,\n        ),\n        apiServerAccessProfile: typedProps.apiServerAccessProfile,\n        diskEncryptionSetID: typedProps.diskEncryptionSetID,\n        enableRBAC:\n          typedProps.enableRBAC !== undefined ? typedProps.enableRBAC : true,\n        nodeResourceGroup: typedProps.nodeResourceGroup,\n        addonProfiles: typedProps.addonProfiles,\n        linuxProfile: typedProps.linuxProfile,\n        windowsProfile: typedProps.windowsProfile,\n        oidcIssuerProfile: typedProps.oidcIssuerProfile,\n        securityProfile: typedProps.securityProfile,\n        storageProfile: typedProps.storageProfile,\n        httpProxyConfig: typedProps.httpProxyConfig,\n        workloadAutoScalerProfile: typedProps.workloadAutoScalerProfile,\n        disableLocalAccounts: typedProps.disableLocalAccounts,\n        publicNetworkAccess: typedProps.publicNetworkAccess,\n        supportPlan: typedProps.supportPlan,\n      },\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR AKS CLUSTER OPERATIONS\n  // =============================================================================\n\n  /**\n   * Get the FQDN of the cluster\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n\n  /**\n   * Get the private FQDN of the cluster (if private cluster is enabled)\n   */\n  public get privateFqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.privateFQDN}`;\n  }\n\n  /**\n   * Get the Kubernetes configuration for the cluster\n   *\n   * This retrieves the cluster admin credentials using an azapi_resource_action.\n   * The kubeConfig is base64 encoded and contains the full kubectl configuration.\n   */\n  public get kubeConfig(): string {\n    // Access the kubeConfig from the credential action's output\n    // The output structure is: { kubeConfigs: [{ value: \"base64-encoded-config\" }] }\n    return `\\${${(this.credentialAction as any).fqn}.output.kubeConfigs[0].value}`;\n  }\n\n  /**\n   * Get the current Kubernetes version running on the cluster\n   */\n  public get currentKubernetesVersion(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.currentKubernetesVersion}`;\n  }\n\n  /**\n   * Get the node resource group name\n   */\n  public get nodeResourceGroupName(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.nodeResourceGroup}`;\n  }\n\n  /**\n   * Add a tag to the AKS Cluster\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 AKS Cluster\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   * Transforms autoScalerProfile properties from camelCase to kebab-case\n   * The Azure AKS API requires kebab-case for autoScalerProfile properties\n   */\n  private _transformAutoScalerProfile(\n    profile?: AksClusterAutoScalerProfile,\n  ): any {\n    if (!profile) {\n      return undefined;\n    }\n\n    return {\n      \"balance-similar-node-groups\": profile.balanceSimilarNodeGroups,\n      expander: profile.expander,\n      \"max-empty-bulk-delete\": profile.maxEmptyBulkDelete,\n      \"max-graceful-termination-sec\": profile.maxGracefulTerminationSec,\n      \"max-node-provision-time\": profile.maxNodeProvisionTime,\n      \"max-total-unready-percentage\": profile.maxTotalUnreadyPercentage,\n      \"new-pod-scale-up-delay\": profile.newPodScaleUpDelay,\n      \"ok-total-unready-count\": profile.okTotalUnreadyCount,\n      \"scan-interval\": profile.scanInterval,\n      \"scale-down-delay-after-add\": profile.scaleDownDelayAfterAdd,\n      \"scale-down-delay-after-delete\": profile.scaleDownDelayAfterDelete,\n      \"scale-down-delay-after-failure\": profile.scaleDownDelayAfterFailure,\n      \"scale-down-unneeded-time\": profile.scaleDownUnneededTime,\n      \"scale-down-unready-time\": profile.scaleDownUnreadyTime,\n      \"scale-down-utilization-threshold\": profile.scaleDownUtilizationThreshold,\n      \"skip-nodes-with-local-storage\": profile.skipNodesWithLocalStorage,\n      \"skip-nodes-with-system-pods\": profile.skipNodesWithSystemPods,\n    };\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 AKS clusters\n      // kubernetesVersion changes frequently during upgrades\n      // agentPoolProfiles can be managed separately\n      const validIgnoreChanges = this.props.ignoreChanges.filter(\n        (change) => change !== \"dnsPrefix\", // dnsPrefix cannot be changed after creation\n      );\n\n      if (validIgnoreChanges.length > 0) {\n        this.terraformResource.addOverride(\"lifecycle\", [\n          {\n            ignore_changes: validIgnoreChanges,\n          },\n        ]);\n      }\n    }\n  }\n}\n"]}

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

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

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

@@ -0,0 +1,19 @@
+"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("./aks-cluster-schemas"), exports);
+__exportStar(require("./aks-cluster"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtYWtzL2xpYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0RBQXNDO0FBQ3RDLGdEQUE4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2Frcy1jbHVzdGVyLXNjaGVtYXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Frcy1jbHVzdGVyXCI7XG4iXX0=

package/lib/azure-aks/test/aks-cluster.integ.d.ts

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