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.30.0 published on Friday, Feb 23, 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.30.0 published on Friday, Feb 23, 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.

    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    CreationData: {
    SourceResourceId: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
    },
    EnableFIPS: pulumi.Bool(true),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("creationData", Map.of("sourceResourceId", "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1")),
                    Map.entry("enableFIPS", true),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(false)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
        addon_profiles={},
        agent_pool_profiles=[{
            "count": 3,
            "creationData": azure_native.containerservice.CreationDataArgs(
                source_resource_id="/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",
        }],
        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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                NatGatewayProfile = new AzureNative.ContainerService.Inputs.ManagedClusterNATGatewayProfileArgs
                {
                    ManagedOutboundIPProfile = new AzureNative.ContainerService.Inputs.ManagedClusterManagedOutboundIPProfileArgs
                    {
                        Count = 2,
                    },
                },
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(false),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerSku: pulumi.String("standard"),
    NatGatewayProfile: interface{}{
    ManagedOutboundIPProfile: &containerservice.ManagedClusterManagedOutboundIPProfileArgs{
    Count: pulumi.Int(2),
    },
    },
    OutboundType: pulumi.String("managedNATGateway"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", false),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("natGatewayProfile", Map.of("managedOutboundIPProfile", Map.of("count", 2))),
                    Map.entry("outboundType", "managedNATGateway")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_sku="standard",
            nat_gateway_profile={
                "managedOutboundIPProfile": azure_native.containerservice.ManagedClusterManagedOutboundIPProfileArgs(
                    count=2,
                ),
            },
            outbound_type="managedNATGateway",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "Linux",
                    Type = "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 = "standard",
                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 = "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.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("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("hostGroupID", "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(false)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableEncryptionAtHost: pulumi.Bool(true),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableEncryptionAtHost", true),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableFIPS: pulumi.Bool(true),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableFIPS", true),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(false)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "MIG3g",
                    Mode = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    GpuInstanceProfile: pulumi.String("MIG3g"),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("gpuInstanceProfile", "MIG3g"),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_ND96asr_v4")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .httpProxyConfig(Map.ofEntries(
                    Map.entry("httpProxy", "http://myproxy.server.com:8080"),
                    Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
                    Map.entry("noProxy",                 
                        "localhost",
                        "127.0.0.1"),
                    Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                ))
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="MIG3g",
            mode="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .httpProxyConfig(Map.ofEntries(
                    Map.entry("httpProxy", "http://myproxy.server.com:8080"),
                    Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
                    Map.entry("noProxy",                 
                        "localhost",
                        "127.0.0.1"),
                    Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                ))
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Base",
                Tier = "Premium",
            },
            SupportPlan = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableEncryptionAtHost: pulumi.Bool(true),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Base"),
    Tier: pulumi.String("Premium"),
    },
    SupportPlan: pulumi.String("AKSLongTermSupport"),
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableEncryptionAtHost", true),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .apiServerAccessProfile(Map.of("disableRunCommand", true))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Base"),
                    Map.entry("tier", "Premium")
                ))
                .supportPlan("AKSLongTermSupport")
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="Base",
            tier="Premium",
        ),
        support_plan="AKSLongTermSupport",
        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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    NodePublicIPPrefixID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    NodePublicIPPrefixID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("nodePublicIPPrefixID", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            node_public_ip_prefix_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsSKU = "AzureLinux",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsSKU: pulumi.String("AzureLinux"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osSKU", "AzureLinux"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .httpProxyConfig(Map.ofEntries(
                    Map.entry("httpProxy", "http://myproxy.server.com:8080"),
                    Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
                    Map.entry("noProxy",                 
                        "localhost",
                        "127.0.0.1"),
                    Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                ))
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_sku="AzureLinux",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    ProximityPlacementGroupID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    ProximityPlacementGroupID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("proximityPlacementGroupID", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            proximity_placement_group_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        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="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: "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",
        },
    });
    
    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .kubernetesVersion("")
                .linuxProfile(Map.ofEntries(
                    Map.entry("adminUsername", "azureuser"),
                    Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
                ))
                .location("location1")
                .networkProfile(Map.ofEntries(
                    Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                    Map.entry("loadBalancerSku", "standard"),
                    Map.entry("outboundType", "loadBalancer")
                ))
                .podIdentityProfile(Map.ofEntries(
                    Map.entry("allowNetworkPluginKubenet", true),
                    Map.entry("enabled", true)
                ))
                .resourceGroupName("rg1")
                .resourceName("clustername1")
                .servicePrincipalProfile(Map.ofEntries(
                    Map.entry("clientId", "clientid"),
                    Map.entry("secret", "secret")
                ))
                .sku(Map.ofEntries(
                    Map.entry("name", "Basic"),
                    Map.entry("tier", "Free")
                ))
                .tags(Map.ofEntries(
                    Map.entry("archv2", ""),
                    Map.entry("tier", "production")
                ))
                .windowsProfile(Map.ofEntries(
                    Map.entry("adminPassword", "replacePassword1234$"),
                    Map.entry("adminUsername", "azureuser")
                ))
                .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="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            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.ContainerServiceLinuxProfileResponseArgs(
            admin_username="azureuser",
            ssh={
                "publicKeys": [azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                    key_data="keydata",
                )],
            },
        ),
        location="location1",
        network_profile=azure_native.containerservice.ContainerServiceNetworkProfileResponseArgs(
            load_balancer_profile={
                "managedOutboundIPs": azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                    count=2,
                ),
            },
            load_balancer_sku="standard",
            outbound_type="loadBalancer",
        ),
        pod_identity_profile=azure_native.containerservice.ManagedClusterPodIdentityProfileArgs(
            allow_network_plugin_kubenet=True,
            enabled=True,
        ),
        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="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: "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",
        },
        podIdentityProfile: {
            allowNetworkPluginKubenet: true,
            enabled: true,
        },
        resourceGroupName: "rg1",
        resourceName: "clustername1",
        servicePrincipalProfile: {
            clientId: "clientid",
            secret: "secret",
        },
        sku: {
            name: "Basic",
            tier: "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
          kubernetesVersion:
          linuxProfile:
            adminUsername: azureuser
            ssh:
              publicKeys:
                - keyData: keydata
          location: location1
          networkProfile:
            loadBalancerProfile:
              managedOutboundIPs:
                count: 2
            loadBalancerSku: standard
            outboundType: loadBalancer
          podIdentityProfile:
            allowNetworkPluginKubenet: true
            enabled: true
          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 RunCommand disabled

    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 = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "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 = "standard",
                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 = "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.ManagedClusterAgentPoolProfileArgs{
    {
    Count: pulumi.Int(3),
    EnableEncryptionAtHost: pulumi.Bool(true),
    EnableNodePublicIP: pulumi.Bool(true),
    Mode: pulumi.String("System"),
    Name: pulumi.String("nodepool1"),
    OsType: pulumi.String("Linux"),
    Type: pulumi.String("VirtualMachineScaleSets"),
    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.ContainerServiceLinuxProfileResponse{
    AdminUsername: pulumi.String("azureuser"),
    Ssh: interface{}{
    PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
    &containerservice.ContainerServiceSshPublicKeyArgs{
    KeyData: pulumi.String("keydata"),
    },
    },
    },
    },
    Location: pulumi.String("location1"),
    NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
    LoadBalancerProfile: interface{}{
    ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
    Count: pulumi.Int(2),
    },
    },
    LoadBalancerSku: pulumi.String("standard"),
    OutboundType: pulumi.String("loadBalancer"),
    },
    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("Free"),
    },
    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 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(Map.ofEntries(
                    Map.entry("count", 3),
                    Map.entry("enableEncryptionAtHost", true),
                    Map.entry("enableNodePublicIP", true),
                    Map.entry("mode", "System"),
                    Map.entry("name", "nodepool1"),
                    Map.entry("osType", "Linux"),
                    Map.entry("type", "VirtualMachineScaleSets"),
                    Map.entry("vmSize", "Standard_DS2_v2")
                ))
                .apiServerAccessProfile(Map.of("disableRunCommand", true))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))