1. Packages
  2. Azure Native
  3. API Docs
  4. containerservice
  5. ManagedCluster
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.44.1 published on Thursday, Jun 6, 2024 by Pulumi

azure-native.containerservice.ManagedCluster

Explore with Pulumi AI

azure-native logo
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.44.1 published on Thursday, Jun 6, 2024 by Pulumi

    Managed cluster. Azure REST API version: 2023-04-01. Prior API version in Azure Native 1.x: 2021-03-01.

    Other available API versions: 2017-08-31, 2019-02-01, 2019-06-01, 2021-05-01, 2023-05-02-preview, 2023-06-01, 2023-06-02-preview, 2023-07-01, 2023-07-02-preview, 2023-08-01, 2023-08-02-preview, 2023-09-01, 2023-09-02-preview, 2023-10-01, 2023-10-02-preview, 2023-11-01, 2023-11-02-preview, 2024-01-01, 2024-01-02-preview, 2024-02-01, 2024-02-02-preview, 2024-03-02-preview.

    When creating a managed cluster you must define at least one agent pool inline via the agentPoolProfiles property. The Azure API does not currently allow this property to be updated directly. Instead, additional agent pools can be defined via the AgentPool resource. If needing to change the initial agent pool profile property, you can either trigger the whole cluster to be re-created by using the replaceOnChanges resource option, or make the change directly in Azure then use pulumi refresh to update the stack’s stack to match.

    Example Usage

    Create Managed Cluster using an agent pool snapshot

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    CreationData = new AzureNative.ContainerService.Inputs.CreationDataArgs
                    {
                        SourceResourceId = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
                    },
                    EnableFIPS = true,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = false,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count: pulumi.Int(3),
    					CreationData: &containerservice.CreationDataArgs{
    						SourceResourceId: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
    					},
    					EnableFIPS:         pulumi.Bool(true),
    					EnableNodePublicIP: pulumi.Bool(true),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(false),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.CreationDataArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .creationData(CreationDataArgs.builder()
                        .sourceResourceId("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1")
                        .build())
                    .enableFIPS(true)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(false)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            creation_data=azure_native.containerservice.CreationDataArgs(
                source_resource_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
            ),
            enable_fips=True,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=False,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            creationData: {
                sourceResourceId: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
            },
            enableFIPS: true,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: false,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              creationData:
                sourceResourceId: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1
              enableFIPS: true
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: false
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with AKS-managed NAT gateway as outbound type

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = false,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                NatGatewayProfile = new AzureNative.ContainerService.Inputs.ManagedClusterNATGatewayProfileArgs
                {
                    ManagedOutboundIPProfile = new AzureNative.ContainerService.Inputs.ManagedClusterManagedOutboundIPProfileArgs
                    {
                        Count = 2,
                    },
                },
                OutboundType = AzureNative.ContainerService.OutboundType.ManagedNATGateway,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(false),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				NatGatewayProfile: &containerservice.ManagedClusterNATGatewayProfileArgs{
    					ManagedOutboundIPProfile: &containerservice.ManagedClusterManagedOutboundIPProfileArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				OutboundType: pulumi.String(containerservice.OutboundTypeManagedNATGateway),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterNATGatewayProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterManagedOutboundIPProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(false)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerSku("standard")
                    .natGatewayProfile(ManagedClusterNATGatewayProfileArgs.builder()
                        .managedOutboundIPProfile(ManagedClusterManagedOutboundIPProfileArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .outboundType("managedNATGateway")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=False,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            nat_gateway_profile=azure_native.containerservice.ManagedClusterNATGatewayProfileArgs(
                managed_outbound_ip_profile=azure_native.containerservice.ManagedClusterManagedOutboundIPProfileArgs(
                    count=2,
                ),
            ),
            outbound_type=azure_native.containerservice.OutboundType.MANAGED_NAT_GATEWAY,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: false,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            natGatewayProfile: {
                managedOutboundIPProfile: {
                    count: 2,
                },
            },
            outboundType: azure_native.containerservice.OutboundType.ManagedNATGateway,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: false
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerSku: standard
            natGatewayProfile:
              managedOutboundIPProfile:
                count: 2
            outboundType: managedNATGateway
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with Azure KeyVault Secrets Provider Addon

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = 
            {
                { "azureKeyvaultSecretsProvider", new AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileArgs
                {
                    Config = 
                    {
                        { "enableSecretRotation", "true" },
                        { "rotationPollInterval", "2m" },
                    },
                    Enabled = true,
                } },
            },
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: containerservice.ManagedClusterAddonProfileMap{
    				"azureKeyvaultSecretsProvider": &containerservice.ManagedClusterAddonProfileArgs{
    					Config: pulumi.StringMap{
    						"enableSecretRotation": pulumi.String("true"),
    						"rotationPollInterval": pulumi.String("2m"),
    					},
    					Enabled: pulumi.Bool(true),
    				},
    			},
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(true),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles(Map.of("azureKeyvaultSecretsProvider", Map.ofEntries(
                    Map.entry("config", Map.ofEntries(
                        Map.entry("enableSecretRotation", "true"),
                        Map.entry("rotationPollInterval", "2m")
                    )),
                    Map.entry("enabled", true)
                )))
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={
            "azureKeyvaultSecretsProvider": azure_native.containerservice.ManagedClusterAddonProfileArgs(
                config={
                    "enableSecretRotation": "true",
                    "rotationPollInterval": "2m",
                },
                enabled=True,
            ),
        },
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {
            azureKeyvaultSecretsProvider: {
                config: {
                    enableSecretRotation: "true",
                    rotationPollInterval: "2m",
                },
                enabled: true,
            },
        },
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles:
            azureKeyvaultSecretsProvider:
              config:
                enableSecretRotation: 'true'
                rotationPollInterval: 2m
              enabled: true
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with Dedicated Host Group

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    HostGroupID = "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = false,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(true),
    					HostGroupID:        pulumi.String("/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(false),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .hostGroupID("/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(false)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            host_group_id="/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=False,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            hostGroupID: "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: false,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              hostGroupID: /subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: false
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with EncryptionAtHost enabled

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableEncryptionAtHost = true,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:                  pulumi.Int(3),
    					EnableEncryptionAtHost: pulumi.Bool(true),
    					EnableNodePublicIP:     pulumi.Bool(true),
    					Mode:                   pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:                   pulumi.String("nodepool1"),
    					OsType:                 pulumi.String(containerservice.OSTypeLinux),
    					Type:                   pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:                 pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableEncryptionAtHost(true)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_encryption_at_host=True,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableEncryptionAtHost: true,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableEncryptionAtHost: true
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with FIPS enabled OS

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableFIPS = true,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = false,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableFIPS:         pulumi.Bool(true),
    					EnableNodePublicIP: pulumi.Bool(true),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(false),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableFIPS(true)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(false)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_fips=True,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=False,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableFIPS: true,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: false,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableFIPS: true
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: false
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with GPUMIG

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    GpuInstanceProfile = AzureNative.ContainerService.GPUInstanceProfile.MIG3g,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_ND96asr_v4",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
            {
                HttpProxy = "http://myproxy.server.com:8080",
                HttpsProxy = "https://myproxy.server.com:8080",
                NoProxy = new[]
                {
                    "localhost",
                    "127.0.0.1",
                },
                TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(true),
    					GpuInstanceProfile: pulumi.String(containerservice.GPUInstanceProfileMIG3g),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_ND96asr_v4"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
    				HttpProxy:  pulumi.String("http://myproxy.server.com:8080"),
    				HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
    				NoProxy: pulumi.StringArray{
    					pulumi.String("localhost"),
    					pulumi.String("127.0.0.1"),
    				},
    				TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
    			},
    			KubernetesVersion: pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterHTTPProxyConfigArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .gpuInstanceProfile("MIG3g")
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_ND96asr_v4")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .httpProxyConfig(ManagedClusterHTTPProxyConfigArgs.builder()
                    .httpProxy("http://myproxy.server.com:8080")
                    .httpsProxy("https://myproxy.server.com:8080")
                    .noProxy(                
                        "localhost",
                        "127.0.0.1")
                    .trustedCa("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                    .build())
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            gpu_instance_profile=azure_native.containerservice.GPUInstanceProfile.MIG3G,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_ND96asr_v4",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
            http_proxy="http://myproxy.server.com:8080",
            https_proxy="https://myproxy.server.com:8080",
            no_proxy=[
                "localhost",
                "127.0.0.1",
            ],
            trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        ),
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            gpuInstanceProfile: azure_native.containerservice.GPUInstanceProfile.MIG3g,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_ND96asr_v4",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        httpProxyConfig: {
            httpProxy: "http://myproxy.server.com:8080",
            httpsProxy: "https://myproxy.server.com:8080",
            noProxy: [
                "localhost",
                "127.0.0.1",
            ],
            trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        },
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              gpuInstanceProfile: MIG3g
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_ND96asr_v4
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          httpProxyConfig:
            httpProxy: http://myproxy.server.com:8080
            httpsProxy: https://myproxy.server.com:8080
            noProxy:
              - localhost
              - 127.0.0.1
            trustedCa: Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with HTTP proxy configured

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
            {
                HttpProxy = "http://myproxy.server.com:8080",
                HttpsProxy = "https://myproxy.server.com:8080",
                NoProxy = new[]
                {
                    "localhost",
                    "127.0.0.1",
                },
                TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(true),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
    				HttpProxy:  pulumi.String("http://myproxy.server.com:8080"),
    				HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
    				NoProxy: pulumi.StringArray{
    					pulumi.String("localhost"),
    					pulumi.String("127.0.0.1"),
    				},
    				TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
    			},
    			KubernetesVersion: pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterHTTPProxyConfigArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .httpProxyConfig(ManagedClusterHTTPProxyConfigArgs.builder()
                    .httpProxy("http://myproxy.server.com:8080")
                    .httpsProxy("https://myproxy.server.com:8080")
                    .noProxy(                
                        "localhost",
                        "127.0.0.1")
                    .trustedCa("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                    .build())
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
            http_proxy="http://myproxy.server.com:8080",
            https_proxy="https://myproxy.server.com:8080",
            no_proxy=[
                "localhost",
                "127.0.0.1",
            ],
            trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        ),
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        httpProxyConfig: {
            httpProxy: "http://myproxy.server.com:8080",
            httpsProxy: "https://myproxy.server.com:8080",
            noProxy: [
                "localhost",
                "127.0.0.1",
            ],
            trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        },
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          httpProxyConfig:
            httpProxy: http://myproxy.server.com:8080
            httpsProxy: https://myproxy.server.com:8080
            noProxy:
              - localhost
              - 127.0.0.1
            trustedCa: Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with LongTermSupport

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableEncryptionAtHost = true,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            ApiServerAccessProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAPIServerAccessProfileArgs
            {
                DisableRunCommand = true,
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = AzureNative.ContainerService.ManagedClusterSKUName.Base,
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Premium,
            },
            SupportPlan = AzureNative.ContainerService.KubernetesSupportPlan.AKSLongTermSupport,
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:                  pulumi.Int(3),
    					EnableEncryptionAtHost: pulumi.Bool(true),
    					EnableNodePublicIP:     pulumi.Bool(true),
    					Mode:                   pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:                   pulumi.String("nodepool1"),
    					OsType:                 pulumi.String(containerservice.OSTypeLinux),
    					Type:                   pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:                 pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			ApiServerAccessProfile: &containerservice.ManagedClusterAPIServerAccessProfileArgs{
    				DisableRunCommand: pulumi.Bool(true),
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String(containerservice.ManagedClusterSKUNameBase),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierPremium),
    			},
    			SupportPlan: pulumi.String(containerservice.KubernetesSupportPlanAKSLongTermSupport),
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAPIServerAccessProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableEncryptionAtHost(true)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .apiServerAccessProfile(ManagedClusterAPIServerAccessProfileArgs.builder()
                    .disableRunCommand(true)
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Base")
                    .tier("Premium")
                    .build())
                .supportPlan("AKSLongTermSupport")
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_encryption_at_host=True,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        api_server_access_profile=azure_native.containerservice.ManagedClusterAPIServerAccessProfileArgs(
            disable_run_command=True,
        ),
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name=azure_native.containerservice.ManagedClusterSKUName.BASE,
            tier=azure_native.containerservice.ManagedClusterSKUTier.PREMIUM,
        ),
        support_plan=azure_native.containerservice.KubernetesSupportPlan.AKS_LONG_TERM_SUPPORT,
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableEncryptionAtHost: true,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        apiServerAccessProfile: {
            disableRunCommand: true,
        },
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: azure_native.containerservice.ManagedClusterSKUName.Base,
            tier: azure_native.containerservice.ManagedClusterSKUTier.Premium,
        },
        supportPlan: azure_native.containerservice.KubernetesSupportPlan.AKSLongTermSupport,
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableEncryptionAtHost: true
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          apiServerAccessProfile:
            disableRunCommand: true
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Base
            tier: Premium
          supportPlan: AKSLongTermSupport
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with Node Public IP Prefix

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    NodePublicIPPrefixID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:                pulumi.Int(3),
    					EnableNodePublicIP:   pulumi.Bool(true),
    					Mode:                 pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:                 pulumi.String("nodepool1"),
    					NodePublicIPPrefixID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
    					OsType:               pulumi.String(containerservice.OSTypeLinux),
    					Type:                 pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:               pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .nodePublicIPPrefixID("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            node_public_ip_prefix_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            nodePublicIPPrefixID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              nodePublicIPPrefixID: /subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with OSSKU

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsSKU = AzureNative.ContainerService.OSSKU.AzureLinux,
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
            {
                HttpProxy = "http://myproxy.server.com:8080",
                HttpsProxy = "https://myproxy.server.com:8080",
                NoProxy = new[]
                {
                    "localhost",
                    "127.0.0.1",
                },
                TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(true),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsSKU:              pulumi.String(containerservice.OSSKUAzureLinux),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
    				HttpProxy:  pulumi.String("http://myproxy.server.com:8080"),
    				HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
    				NoProxy: pulumi.StringArray{
    					pulumi.String("localhost"),
    					pulumi.String("127.0.0.1"),
    				},
    				TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
    			},
    			KubernetesVersion: pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterHTTPProxyConfigArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osSKU("AzureLinux")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .httpProxyConfig(ManagedClusterHTTPProxyConfigArgs.builder()
                    .httpProxy("http://myproxy.server.com:8080")
                    .httpsProxy("https://myproxy.server.com:8080")
                    .noProxy(                
                        "localhost",
                        "127.0.0.1")
                    .trustedCa("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                    .build())
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_sku=azure_native.containerservice.OSSKU.AZURE_LINUX,
            os_type=azure_native.containerservice.OSType.LINUX,
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
            http_proxy="http://myproxy.server.com:8080",
            https_proxy="https://myproxy.server.com:8080",
            no_proxy=[
                "localhost",
                "127.0.0.1",
            ],
            trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        ),
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osSKU: azure_native.containerservice.OSSKU.AzureLinux,
            osType: azure_native.containerservice.OSType.Linux,
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        httpProxyConfig: {
            httpProxy: "http://myproxy.server.com:8080",
            httpsProxy: "https://myproxy.server.com:8080",
            noProxy: [
                "localhost",
                "127.0.0.1",
            ],
            trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        },
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osSKU: AzureLinux
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          httpProxyConfig:
            httpProxy: http://myproxy.server.com:8080
            httpsProxy: https://myproxy.server.com:8080
            noProxy:
              - localhost
              - 127.0.0.1
            trustedCa: Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with PPG

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    ProximityPlacementGroupID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:                     pulumi.Int(3),
    					EnableNodePublicIP:        pulumi.Bool(true),
    					Mode:                      pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:                      pulumi.String("nodepool1"),
    					OsType:                    pulumi.String(containerservice.OSTypeLinux),
    					ProximityPlacementGroupID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
    					Type:                      pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:                    pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .proximityPlacementGroupID("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder()
                        .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                            .keyData("keydata")
                            .build())
                        .build())
                    .build())
                .location("location1")
                .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                    .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                        .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                            .count(2)
                            .build())
                        .build())
                    .loadBalancerSku("standard")
                    .outboundType("loadBalancer")
                    .build())
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                    .clientId("clientid")
                    .secret("secret")
                    .build())
                .sku(ManagedClusterSKUArgs.builder()
                    .name("Basic")
                    .tier("Free")
                    .build())
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                    .adminPassword("replacePassword1234$")
                    .adminUsername("azureuser")
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            count=3,
            enable_node_public_ip=True,
            mode=azure_native.containerservice.AgentPoolMode.SYSTEM,
            name="nodepool1",
            os_type=azure_native.containerservice.OSType.LINUX,
            proximity_placement_group_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
            type=azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
            vm_size="Standard_DS2_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        kubernetes_version="",
        linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
            admin_username="azureuser",
            ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
                public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            ),
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
            load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
                managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            ),
            load_balancer_sku=azure_native.containerservice.LoadBalancerSku.STANDARD,
            outbound_type=azure_native.containerservice.OutboundType.LOAD_BALANCER,
        ),
        resource_group_name="rg1",
        resource_name_="clustername1",
        service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
            client_id="clientid",
            secret="secret",
        ),
        sku=azure_native.containerservice.ManagedClusterSKUArgs(
            name="Basic",
            tier=azure_native.containerservice.ManagedClusterSKUTier.FREE,
        ),
        tags={
            "archv2": "",
            "tier": "production",
        },
        windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
            admin_password="replacePassword1234$",
            admin_username="azureuser",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            count: 3,
            enableNodePublicIP: true,
            mode: azure_native.containerservice.AgentPoolMode.System,
            name: "nodepool1",
            osType: azure_native.containerservice.OSType.Linux,
            proximityPlacementGroupID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
            type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
            vmSize: "Standard_DS2_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        kubernetesVersion: "",
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "keydata",
                }],
            },
        },
        location: "location1",
        networkProfile: {
            loadBalancerProfile: {
                managedOutboundIPs: {
                    count: 2,
                },
            },
            loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
            outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: azure_native.containerservice.ManagedClusterSKUTier.Free,
        },
        tags: {
            archv2: "",
            tier: "production",
        },
        windowsProfile: {
            adminPassword: "replacePassword1234$",
            adminUsername: "azureuser",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              proximityPlacementGroupID: /subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1
              type: VirtualMachineScaleSets
              vmSize: Standard_DS2_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          resourceGroupName: rg1
          resourceName: clustername1
          servicePrincipalProfile:
            clientId: clientid
            secret: secret
          sku:
            name: Basic
            tier: Free
          tags:
            archv2:
            tier: production
          windowsProfile:
            adminPassword: replacePassword1234$
            adminUsername: azureuser
    

    Create Managed Cluster with PodIdentity enabled

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
        {
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = AzureNative.ContainerService.AgentPoolMode.System,
                    Name = "nodepool1",
                    OsType = AzureNative.ContainerService.OSType.Linux,
                    Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                    VmSize = "Standard_DS2_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = new[]
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
                OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
            },
            PodIdentityProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityProfileArgs
            {
                AllowNetworkPluginKubenet = true,
                Enabled = true,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
    			AddonProfiles: nil,
    			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
    				&containerservice.ManagedClusterAgentPoolProfileArgs{
    					Count:              pulumi.Int(3),
    					EnableNodePublicIP: pulumi.Bool(true),
    					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
    					Name:               pulumi.String("nodepool1"),
    					OsType:             pulumi.String(containerservice.OSTypeLinux),
    					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
    					VmSize:             pulumi.String("Standard_DS2_v2"),
    				},
    			},
    			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
    				ScaleDownDelayAfterAdd: pulumi.String("15m"),
    				ScanInterval:           pulumi.String("20s"),
    			},
    			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
    			DnsPrefix:               pulumi.String("dnsprefix1"),
    			EnablePodSecurityPolicy: pulumi.Bool(true),
    			EnableRBAC:              pulumi.Bool(true),
    			KubernetesVersion:       pulumi.String(""),
    			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
    				AdminUsername: pulumi.String("azureuser"),
    				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
    					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    						&containerservice.ContainerServiceSshPublicKeyArgs{
    							KeyData: pulumi.String("keydata"),
    						},
    					},
    				},
    			},
    			Location: pulumi.String("location1"),
    			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
    				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
    					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    						Count: pulumi.Int(2),
    					},
    				},
    				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
    				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
    			},
    			PodIdentityProfile: &containerservice.ManagedClusterPodIdentityProfileArgs{
    				AllowNetworkPluginKubenet: pulumi.Bool(true),
    				Enabled:                   pulumi.Bool(true),
    			},
    			ResourceGroupName: pulumi.String("rg1"),
    			ResourceName:      pulumi.String("clustername1"),
    			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
    				ClientId: pulumi.String("clientid"),
    				Secret:   pulumi.String("secret"),
    			},
    			Sku: &containerservice.ManagedClusterSKUArgs{
    				Name: pulumi.String("Basic"),
    				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
    			},
    			Tags: pulumi.StringMap{
    				"archv2": pulumi.String(""),
    				"tier":   pulumi.String("production"),
    			},
    			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
    				AdminPassword: pulumi.String("replacePassword1234$"),
    				AdminUsername: pulumi.String("azureuser"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.containerservice.ManagedCluster;
    import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
    import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPodIdentityProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
    import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
                .addonProfiles()
                .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                    .count(3)
                    .enableNodePublicIP(true)
                    .mode("System")
                    .name("nodepool1")
                    .osType("Linux")
                    .type("VirtualMachineScaleSets")
                    .vmSize("Standard_DS2_v2")
                    .build())
                .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                    .scaleDownDelayAfterAdd("15m")
                    .scanInterval("20s")
                    .build())
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                    .adminUsername("azureuser")
                    .ssh(ContainerServiceSshConfigurationArgs.builder