1. Packages
  2. Azure Native
  3. API Docs
  4. containerservice
  5. ManagedCluster
Azure Native v1.103.0 published on Friday, Jun 2, 2023 by Pulumi

azure-native.containerservice.ManagedCluster

Explore with Pulumi AI

azure-native logo
Azure Native v1.103.0 published on Friday, Jun 2, 2023 by Pulumi

    Managed cluster. API Version: 2021-03-01.

    Example Usage

    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" },
                    },
                    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",
            },
        });
    
    });
    

    Coming soon!

    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.of("enableSecretRotation", "true")),
                    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",
                },
                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",
                },
                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'
              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 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",
            },
        });
    
    });
    

    Coming soon!

    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",
            },
        });
    
    });
    

    Coming soon!

    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",
            },
        });
    
    });
    

    Coming soon!

    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",
            },
        });
    
    });
    

    Coming soon!

    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 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",
            },
        });
    
    });
    

    Coming soon!

    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 = "CBLMariner",
                    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",
            },
        });
    
    });
    

    Coming soon!

    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", "CBLMariner"),
                    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="CBLMariner",
            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: "CBLMariner",
            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: CBLMariner
              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",
            },
        });
    
    });
    

    Coming soon!

    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",
            },
        });
    
    });
    

    Coming soon!

    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 Private Cluster with fqdn subdomain specified

    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
            {
                EnablePrivateCluster = true,
                PrivateDNSZone = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
            },
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            FqdnSubdomain = "domain1",
            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",
            },
        });
    
    });
    

    Coming soon!

    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.ofEntries(
                    Map.entry("enablePrivateCluster", true),
                    Map.entry("privateDNSZone", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s")
                ))
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .fqdnSubdomain("domain1")
                .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",
        )],
        api_server_access_profile=azure_native.containerservice.ManagedClusterAPIServerAccessProfileArgs(
            enable_private_cluster=True,
            private_dns_zone="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
        ),
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            scale_down_delay_after_add="15m",
            scan_interval="20s",
        ),
        enable_pod_security_policy=True,
        enable_rbac=True,
        fqdn_subdomain="domain1",
        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",
        }],
        apiServerAccessProfile: {
            enablePrivateCluster: true,
            privateDNSZone: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
        },
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        fqdnSubdomain: "domain1",
        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
          apiServerAccessProfile:
            enablePrivateCluster: true
            privateDNSZone: /subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          enablePodSecurityPolicy: true
          enableRBAC: true
          fqdnSubdomain: domain1
          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/Update AAD Managed Cluster with EnableAzureRBAC

    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()
        {
            AadProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAADProfileArgs
            {
                EnableAzureRBAC = true,
                Managed = true,
            },
            AddonProfiles = null,
            AgentPoolProfiles = new[]
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    AvailabilityZones = new[]
                    {
                        "1",
                        "2",
                        "3",
                    },
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "VirtualMachineScaleSets",
                    VmSize = "Standard_DS1_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",
            },
        });
    
    });
    

    Coming soon!

    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()        
                .aadProfile(Map.ofEntries(
                    Map.entry("enableAzureRBAC", true),
                    Map.entry("managed", true)
                ))
                .addonProfiles()
                .agentPoolProfiles(Map.ofEntries(
                    Map.entry("availabilityZones",                 
                        "1",
                        "2",
                        "3"),
                    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_DS1_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",
        aad_profile=azure_native.containerservice.ManagedClusterAADProfileArgs(
            enable_azure_rbac=True,
            managed=True,
        ),
        addon_profiles={},
        agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
            availability_zones=[
                "1",
                "2",
                "3",
            ],
            count=3,
            enable_node_public_ip=True,
            mode="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            vm_size="Standard_DS1_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", {
        aadProfile: {
            enableAzureRBAC: true,
            managed: true,
        },
        addonProfiles: {},
        agentPoolProfiles: [{
            availabilityZones: [
                "1",
                "2",
                "3",
            ],
            count: 3,
            enableNodePublicIP: true,
            mode: "System",
            name: "nodepool1",
            osType: "Linux",
            type: "VirtualMachineScaleSets",
            vmSize: "Standard_DS1_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:
          aadProfile:
            enableAzureRBAC: true
            managed: true
          addonProfiles: {}
          agentPoolProfiles:
            - availabilityZones:
                - '1'
                - '2'
                - '3'
              count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS1_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/Update Managed Cluster

    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
                {
                    AvailabilityZones = new[]
                    {
                        "1",
                        "2",
                        "3",
                    },
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "VirtualMachineScaleSets",
                    VmSize = "Standard_DS1_v2",
                },
            },
            AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
            {
                BalanceSimilarNodeGroups = "true",
                Expander = "priority",
                MaxNodeProvisionTime = "15m",
                NewPodScaleUpDelay = "1m",
                ScaleDownDelayAfterAdd = "15m",
                ScanInterval = "20s",
                SkipNodesWithSystemPods = "false",
            },
            DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
            DnsPrefix = "dnsprefix1",
            EnablePodSecurityPolicy = true,
            EnableRBAC = true,
            Identity = new AzureNative.ContainerService.Inputs.ManagedClusterIdentityArgs
            {
                Type = AzureNative.ContainerService.ResourceIdentityType.UserAssigned,
                UserAssignedIdentities = 
                {
                    { "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", null },
                },
            },
            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",
            },
        });
    
    });
    

    Coming soon!

    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("availabilityZones",                 
                        "1",
                        "2",
                        "3"),
                    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_DS1_v2")
                ))
                .autoScalerProfile(Map.ofEntries(
                    Map.entry("balanceSimilarNodeGroups", "true"),
                    Map.entry("expander", "priority"),
                    Map.entry("maxNodeProvisionTime", "15m"),
                    Map.entry("newPodScaleUpDelay", "1m"),
                    Map.entry("scaleDownDelayAfterAdd", "15m"),
                    Map.entry("scanInterval", "20s"),
                    Map.entry("skipNodesWithSystemPods", "false")
                ))
                .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
                .dnsPrefix("dnsprefix1")
                .enablePodSecurityPolicy(true)
                .enableRBAC(true)
                .identity(Map.ofEntries(
                    Map.entry("type", "UserAssigned"),
                    Map.entry("userAssignedIdentities", Map.of("/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", ))
                ))
                .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(
            availability_zones=[
                "1",
                "2",
                "3",
            ],
            count=3,
            enable_node_public_ip=True,
            mode="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            vm_size="Standard_DS1_v2",
        )],
        auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
            balance_similar_node_groups="true",
            expander="priority",
            max_node_provision_time="15m",
            new_pod_scale_up_delay="1m",
            scale_down_delay_after_add="15m",
            scan_interval="20s",
            skip_nodes_with_system_pods="false",
        ),
        disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dns_prefix="dnsprefix1",
        enable_pod_security_policy=True,
        enable_rbac=True,
        identity=azure_native.containerservice.ManagedClusterIdentityArgs(
            type=azure_native.containerservice.ResourceIdentityType.USER_ASSIGNED,
            user_assigned_identities={
                "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
            },
        ),
        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: [{
            availabilityZones: [
                "1",
                "2",
                "3",
            ],
            count: 3,
            enableNodePublicIP: true,
            mode: "System",
            name: "nodepool1",
            osType: "Linux",
            type: "VirtualMachineScaleSets",
            vmSize: "Standard_DS1_v2",
        }],
        autoScalerProfile: {
            balanceSimilarNodeGroups: "true",
            expander: "priority",
            maxNodeProvisionTime: "15m",
            newPodScaleUpDelay: "1m",
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
            skipNodesWithSystemPods: "false",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        identity: {
            type: azure_native.containerservice.ResourceIdentityType.UserAssigned,
            userAssignedIdentities: {
                "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
            },
        },
        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:
            - availabilityZones:
                - '1'
                - '2'
                - '3'
              count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS1_v2
          autoScalerProfile:
            balanceSimilarNodeGroups: 'true'
            expander: priority
            maxNodeProvisionTime: 15m
            newPodScaleUpDelay: 1m
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
            skipNodesWithSystemPods: 'false'
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          identity:
            type: UserAssigned
            userAssignedIdentities:
              /subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1: {}
          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/Update Managed Cluster with EnableAHUB

    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
                {
                    AvailabilityZones = new[]
                    {
                        "1",
                        "2",
                        "3",
                    },
                    Count = 3,
                    EnableNodePublicIP = true,
                    Mode = "System",
                    Name = "nodepool1",
                    OsType = "Linux",
                    Type = "VirtualMachineScaleSets",
                    VmSize = "Standard_DS1_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,
            Identity = new AzureNative.ContainerService.Inputs.ManagedClusterIdentityArgs
            {
                Type = AzureNative.ContainerService.ResourceIdentityType.UserAssigned,
                UserAssignedIdentities = 
                {
                    { "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", null },
                },
            },
            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",
                LicenseType = "Windows_Server",
            },
        });
    
    });
    

    Coming soon!

    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("availabilityZones",                 
                        "1",
                        "2",
                        "3"),
                    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_DS1_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)
                .identity(Map.ofEntries(
                    Map.entry("type", "UserAssigned"),
                    Map.entry("userAssignedIdentities", Map.of("/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", ))
                ))
                .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"),
                    Map.entry("licenseType", "Windows_Server")
                ))
                .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(
            availability_zones=[
                "1",
                "2",
                "3",
            ],
            count=3,
            enable_node_public_ip=True,
            mode="System",
            name="nodepool1",
            os_type="Linux",
            type="VirtualMachineScaleSets",
            vm_size="Standard_DS1_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,
        identity=azure_native.containerservice.ManagedClusterIdentityArgs(
            type=azure_native.containerservice.ResourceIdentityType.USER_ASSIGNED,
            user_assigned_identities={
                "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
            },
        ),
        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",
            license_type="Windows_Server",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
        addonProfiles: {},
        agentPoolProfiles: [{
            availabilityZones: [
                "1",
                "2",
                "3",
            ],
            count: 3,
            enableNodePublicIP: true,
            mode: "System",
            name: "nodepool1",
            osType: "Linux",
            type: "VirtualMachineScaleSets",
            vmSize: "Standard_DS1_v2",
        }],
        autoScalerProfile: {
            scaleDownDelayAfterAdd: "15m",
            scanInterval: "20s",
        },
        diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        dnsPrefix: "dnsprefix1",
        enablePodSecurityPolicy: true,
        enableRBAC: true,
        identity: {
            type: azure_native.containerservice.ResourceIdentityType.UserAssigned,
            userAssignedIdentities: {
                "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
            },
        },
        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",
            licenseType: "Windows_Server",
        },
    });
    
    resources:
      managedCluster:
        type: azure-native:containerservice:ManagedCluster
        properties:
          addonProfiles: {}
          agentPoolProfiles:
            - availabilityZones:
                - '1'
                - '2'
                - '3'
              count: 3
              enableNodePublicIP: true
              mode: System
              name: nodepool1
              osType: Linux
              type: VirtualMachineScaleSets
              vmSize: Standard_DS1_v2
          autoScalerProfile:
            scaleDownDelayAfterAdd: 15m
            scanInterval: 20s
          diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
          dnsPrefix: dnsprefix1
          enablePodSecurityPolicy: true
          enableRBAC: true
          identity:
            type: UserAssigned
            userAssignedIdentities:
              /subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1: {}
          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
            licenseType: Windows_Server
    

    Create ManagedCluster Resource

    new ManagedCluster(name: string, args: ManagedClusterArgs, opts?: CustomResourceOptions);
    @overload
    def ManagedCluster(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       aad_profile: Optional[ManagedClusterAADProfileArgs] = None,
                       addon_profiles: Optional[Mapping[str, ManagedClusterAddonProfileArgs]] = None,
                       agent_pool_profiles: Optional[Sequence[ManagedClusterAgentPoolProfileArgs]] = None,
                       api_server_access_profile: Optional[ManagedClusterAPIServerAccessProfileArgs] = None,
                       auto_scaler_profile: Optional[ManagedClusterPropertiesAutoScalerProfileArgs] = None,
                       auto_upgrade_profile: Optional[ManagedClusterAutoUpgradeProfileArgs] = None,
                       disable_local_accounts: Optional[bool] = None,
                       disk_encryption_set_id: Optional[str] = None,
                       dns_prefix: Optional[str] = None,
                       enable_pod_security_policy: Optional[bool] = None,
                       enable_rbac: Optional[bool] = None,
                       extended_location: Optional[ExtendedLocationArgs] = None,
                       fqdn_subdomain: Optional[str] = None,
                       http_proxy_config: Optional[ManagedClusterHTTPProxyConfigArgs] = None,
                       identity: Optional[ManagedClusterIdentityArgs] = None,
                       identity_profile: Optional[Mapping[str, ManagedClusterPropertiesIdentityProfileArgs]] = None,
                       kubernetes_version: Optional[str] = None,
                       linux_profile: Optional[ContainerServiceLinuxProfileArgs] = None,
                       location: Optional[str] = None,
                       network_profile: Optional[ContainerServiceNetworkProfileArgs] = None,
                       node_resource_group: Optional[str] = None,
                       pod_identity_profile: Optional[ManagedClusterPodIdentityProfileArgs] = None,
                       private_link_resources: Optional[Sequence[PrivateLinkResourceArgs]] = None,
                       resource_group_name: Optional[str] = None,
                       resource_name_: Optional[str] = None,
                       service_principal_profile: Optional[ManagedClusterServicePrincipalProfileArgs] = None,
                       sku: Optional[ManagedClusterSKUArgs] = None,
                       tags: Optional[Mapping[str, str]] = None,
                       windows_profile: Optional[ManagedClusterWindowsProfileArgs] = None)
    @overload
    def ManagedCluster(resource_name: str,
                       args: ManagedClusterArgs,
                       opts: Optional[ResourceOptions] = None)
    func NewManagedCluster(ctx *Context, name string, args ManagedClusterArgs, opts ...ResourceOption) (*ManagedCluster, error)
    public ManagedCluster(string name, ManagedClusterArgs args, CustomResourceOptions? opts = null)
    public ManagedCluster(String name, ManagedClusterArgs args)
    public ManagedCluster(String name, ManagedClusterArgs args, CustomResourceOptions options)
    
    type: azure-native:containerservice:ManagedCluster
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    name string
    The unique name of the resource.
    args ManagedClusterArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ManagedClusterArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ManagedClusterArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ManagedClusterArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ManagedClusterArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    ManagedCluster Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The ManagedCluster resource accepts the following input properties:

    ResourceGroupName string

    The name of the resource group.

    AadProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterAADProfileArgs

    Profile of Azure Active Directory configuration.

    AddonProfiles Dictionary<string, Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileArgs>

    Profile of managed cluster add-on.

    AgentPoolProfiles List<Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs>

    Properties of the agent pool.

    ApiServerAccessProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterAPIServerAccessProfileArgs

    Access profile for managed cluster API server.

    AutoScalerProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs

    Parameters to be applied to the cluster-autoscaler when enabled

    AutoUpgradeProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterAutoUpgradeProfileArgs

    Profile of auto upgrade configuration.

    DisableLocalAccounts bool

    If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.

    DiskEncryptionSetID string

    ResourceId of the disk encryption set to use for enabling encryption at rest.

    DnsPrefix string

    DNS prefix specified when creating the managed cluster.

    EnablePodSecurityPolicy bool

    (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.

    EnableRBAC bool

    Whether to enable Kubernetes Role-Based Access Control.

    ExtendedLocation Pulumi.AzureNative.ContainerService.Inputs.ExtendedLocationArgs

    The extended location of the Virtual Machine.

    FqdnSubdomain string

    FQDN subdomain specified when creating private cluster with custom private dns zone.

    HttpProxyConfig Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs

    Configurations for provisioning the cluster with HTTP proxy servers.

    Identity Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterIdentityArgs

    The identity of the managed cluster, if configured.

    IdentityProfile Dictionary<string, Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPropertiesIdentityProfileArgs>

    Identities associated with the cluster.

    KubernetesVersion string

    Version of Kubernetes specified when creating the managed cluster.

    LinuxProfile Pulumi.AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs

    Profile for Linux VMs in the container service cluster.

    Location string

    Resource location

    NetworkProfile Pulumi.AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs

    Profile of network configuration.

    NodeResourceGroup string

    Name of the resource group containing agent pool nodes.

    PodIdentityProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityProfileArgs

    Profile of managed cluster pod identity.

    PrivateLinkResources List<Pulumi.AzureNative.ContainerService.Inputs.PrivateLinkResourceArgs>

    Private link resources associated with the cluster.

    ResourceName string

    The name of the managed cluster resource.

    ServicePrincipalProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs

    Information about a service principal identity for the cluster to use for manipulating Azure APIs.

    Sku Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs

    The managed cluster SKU.

    Tags Dictionary<string, string>

    Resource tags

    WindowsProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs

    Profile for Windows VMs in the container service cluster.

    ResourceGroupName string

    The name of the resource group.

    AadProfile ManagedClusterAADProfileArgs

    Profile of Azure Active Directory configuration.

    AddonProfiles map[string]ManagedClusterAddonProfileArgs

    Profile of managed cluster add-on.

    AgentPoolProfiles []ManagedClusterAgentPoolProfileArgs

    Properties of the agent pool.

    ApiServerAccessProfile ManagedClusterAPIServerAccessProfileArgs

    Access profile for managed cluster API server.

    AutoScalerProfile ManagedClusterPropertiesAutoScalerProfileArgs

    Parameters to be applied to the cluster-autoscaler when enabled

    AutoUpgradeProfile ManagedClusterAutoUpgradeProfileArgs

    Profile of auto upgrade configuration.

    DisableLocalAccounts bool

    If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.

    DiskEncryptionSetID string

    ResourceId of the disk encryption set to use for enabling encryption at rest.

    DnsPrefix string

    DNS prefix specified when creating the managed cluster.

    EnablePodSecurityPolicy bool

    (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.

    EnableRBAC bool

    Whether to enable Kubernetes Role-Based Access Control.

    ExtendedLocation ExtendedLocationArgs

    The extended location of the Virtual Machine.

    FqdnSubdomain string

    FQDN subdomain specified when creating private cluster with custom private dns zone.

    HttpProxyConfig ManagedClusterHTTPProxyConfigArgs

    Configurations for provisioning the cluster with HTTP proxy servers.

    Identity ManagedClusterIdentityArgs

    The identity of the managed cluster, if configured.

    IdentityProfile map[string]ManagedClusterPropertiesIdentityProfileArgs

    Identities associated with the cluster.

    KubernetesVersion string

    Version of Kubernetes specified when creating the managed cluster.

    LinuxProfile ContainerServiceLinuxProfileArgs

    Profile for Linux VMs in the container service cluster.

    Location string

    Resource location

    NetworkProfile ContainerServiceNetworkProfileArgs

    Profile of network configuration.

    NodeResourceGroup string

    Name of the resource group containing agent pool nodes.

    PodIdentityProfile ManagedClusterPodIdentityProfileArgs

    Profile of managed cluster pod identity.

    PrivateLinkResources []PrivateLinkResourceArgs

    Private link resources associated with the cluster.

    ResourceName string

    The name of the managed cluster resource.

    ServicePrincipalProfile ManagedClusterServicePrincipalProfileArgs

    Information about a service principal identity for the cluster to use for manipulating Azure APIs.

    Sku ManagedClusterSKUArgs

    The managed cluster SKU.

    Tags map[string]string

    Resource tags

    WindowsProfile ManagedClusterWindowsProfileArgs

    Profile for Windows VMs in the container service cluster.

    resourceGroupName String

    The name of the resource group.

    aadProfile ManagedClusterAADProfileArgs

    Profile of Azure Active Directory configuration.

    addonProfiles Map<String,ManagedClusterAddonProfileArgs>

    Profile of managed cluster add-on.

    agentPoolProfiles List<ManagedClusterAgentPoolProfileArgs>

    Properties of the agent pool.

    apiServerAccessProfile ManagedClusterAPIServerAccessProfileArgs

    Access profile for managed cluster API server.

    autoScalerProfile ManagedClusterPropertiesAutoScalerProfileArgs

    Parameters to be applied to the cluster-autoscaler when enabled

    autoUpgradeProfile ManagedClusterAutoUpgradeProfileArgs

    Profile of auto upgrade configuration.

    disableLocalAccounts Boolean

    If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.

    diskEncryptionSetID String

    ResourceId of the disk encryption set to use for enabling encryption at rest.

    dnsPrefix String

    DNS prefix specified when creating the managed cluster.

    enablePodSecurityPolicy Boolean

    (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.

    enableRBAC Boolean

    Whether to enable Kubernetes Role-Based Access Control.

    extendedLocation ExtendedLocationArgs

    The extended location of the Virtual Machine.

    fqdnSubdomain String

    FQDN subdomain specified when creating private cluster with custom private dns zone.

    httpProxyConfig ManagedClusterHTTPProxyConfigArgs

    Configurations for provisioning the cluster with HTTP proxy servers.

    identity ManagedClusterIdentityArgs

    The identity of the managed cluster, if configured.

    identityProfile Map<String,ManagedClusterPropertiesIdentityProfileArgs>

    Identities associated with the cluster.

    kubernetesVersion String

    Version of Kubernetes specified when creating the managed cluster.

    linuxProfile ContainerServiceLinuxProfileArgs

    Profile for Linux VMs in the container service cluster.

    location String

    Resource location

    networkProfile ContainerServiceNetworkProfileArgs

    Profile of network configuration.

    nodeResourceGroup String

    Name of the resource group containing agent pool nodes.

    podIdentityProfile ManagedClusterPodIdentityProfileArgs

    Profile of managed cluster pod identity.

    privateLinkResources List<PrivateLinkResourceArgs>

    Private link resources associated with the cluster.

    resourceName String

    The name of the managed cluster resource.

    servicePrincipalProfile ManagedClusterServicePrincipalProfileArgs

    Information about a service principal identity for the cluster to use for manipulating Azure APIs.

    sku ManagedClusterSKUArgs

    The managed cluster SKU.

    tags Map<String,String>

    Resource tags

    windowsProfile ManagedClusterWindowsProfileArgs

    Profile for Windows VMs in the container service cluster.

    resourceGroupName string

    The name of the resource group.

    aadProfile ManagedClusterAADProfileArgs

    Profile of Azure Active Directory configuration.

    addonProfiles {[key: string]: ManagedClusterAddonProfileArgs}

    Profile of managed cluster add-on.

    agentPoolProfiles ManagedClusterAgentPoolProfileArgs[]

    Properties of the agent pool.

    apiServerAccessProfile ManagedClusterAPIServerAccessProfileArgs

    Access profile for managed cluster API server.

    autoScalerProfile ManagedClusterPropertiesAutoScalerProfileArgs

    Parameters to be applied to the cluster-autoscaler when enabled

    autoUpgradeProfile ManagedClusterAutoUpgradeProfileArgs

    Profile of auto upgrade configuration.

    disableLocalAccounts boolean

    If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.

    diskEncryptionSetID string

    ResourceId of the disk encryption set to use for enabling encryption at rest.

    dnsPrefix string

    DNS prefix specified when creating the managed cluster.

    enablePodSecurityPolicy boolean

    (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.

    enableRBAC boolean

    Whether to enable Kubernetes Role-Based Access Control.

    extendedLocation ExtendedLocationArgs

    The extended location of the Virtual Machine.

    fqdnSubdomain string

    FQDN subdomain specified when creating private cluster with custom private dns zone.

    httpProxyConfig ManagedClusterHTTPProxyConfigArgs

    Configurations for provisioning the cluster with HTTP proxy servers.

    identity ManagedClusterIdentityArgs

    The identity of the managed cluster, if configured.

    identityProfile {[key: string]: ManagedClusterPropertiesIdentityProfileArgs}

    Identities associated with the cluster.

    kubernetesVersion string

    Version of Kubernetes specified when creating the managed cluster.

    linuxProfile ContainerServiceLinuxProfileArgs

    Profile for Linux VMs in the container service cluster.

    location string

    Resource location

    networkProfile ContainerServiceNetworkProfileArgs

    Profile of network configuration.

    nodeResourceGroup string

    Name of the resource group containing agent pool nodes.

    podIdentityProfile ManagedClusterPodIdentityProfileArgs

    Profile of managed cluster pod identity.

    privateLinkResources PrivateLinkResourceArgs[]

    Private link resources associated with the cluster.

    resourceName string

    The name of the managed cluster resource.

    servicePrincipalProfile ManagedClusterServicePrincipalProfileArgs

    Information about a service principal identity for the cluster to use for manipulating Azure APIs.

    sku ManagedClusterSKUArgs

    The managed cluster SKU.

    tags {[key: string]: string}

    Resource tags

    windowsProfile ManagedClusterWindowsProfileArgs

    Profile for Windows VMs in the container service cluster.

    resource_group_name str

    The name of the resource group.

    aad_profile ManagedClusterAADProfileArgs

    Profile of Azure Active Directory configuration.

    addon_profiles Mapping[str, ManagedClusterAddonProfileArgs]

    Profile of managed cluster add-on.

    agent_pool_profiles Sequence[ManagedClusterAgentPoolProfileArgs]

    Properties of the agent pool.

    api_server_access_profile ManagedClusterAPIServerAccessProfileArgs

    Access profile for managed cluster API server.

    auto_scaler_profile ManagedClusterPropertiesAutoScalerProfileArgs

    Parameters to be applied to the cluster-autoscaler when enabled

    auto_upgrade_profile ManagedClusterAutoUpgradeProfileArgs

    Profile of auto upgrade configuration.

    disable_local_accounts bool

    If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.

    disk_encryption_set_id str

    ResourceId of the disk encryption set to use for enabling encryption at rest.

    dns_prefix str

    DNS prefix specified when creating the managed cluster.

    enable_pod_security_policy bool

    (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.

    enable_rbac bool

    Whether to enable Kubernetes Role-Based Access Control.

    extended_location ExtendedLocationArgs

    The extended location of the Virtual Machine.

    fqdn_subdomain str

    FQDN subdomain specified when creating private cluster with custom private dns zone.

    http_proxy_config ManagedClusterHTTPProxyConfigArgs

    Configurations for provisioning the cluster with HTTP proxy servers.

    identity ManagedClusterIdentityArgs

    The identity of the managed cluster, if configured.

    identity_profile Mapping[str, ManagedClusterPropertiesIdentityProfileArgs]

    Identities associated with the cluster.

    kubernetes_version str

    Version of Kubernetes specified when creating the managed cluster.

    linux_profile ContainerServiceLinuxProfileArgs

    Profile for Linux VMs in the container service cluster.

    location str

    Resource location

    network_profile ContainerServiceNetworkProfileArgs

    Profile of network configuration.

    node_resource_group str

    Name of the resource group containing agent pool nodes.

    pod_identity_profile ManagedClusterPodIdentityProfileArgs

    Profile of managed cluster pod identity.

    private_link_resources Sequence[PrivateLinkResourceArgs]

    Private link resources associated with the cluster.

    resource_name str

    The name of the managed cluster resource.

    service_principal_profile ManagedClusterServicePrincipalProfileArgs

    Information about a service principal identity for the cluster to use for manipulating Azure APIs.

    sku ManagedClusterSKUArgs

    The managed cluster SKU.

    tags Mapping[str, str]

    Resource tags

    windows_profile ManagedClusterWindowsProfileArgs

    Profile for Windows VMs in the container service cluster.

    resourceGroupName String

    The name of the resource group.

    aadProfile Property Map

    Profile of Azure Active Directory configuration.

    addonProfiles Map<Property Map>

    Profile of managed cluster add-on.

    agentPoolProfiles List<Property Map>

    Properties of the agent pool.

    apiServerAccessProfile Property Map

    Access profile for managed cluster API server.

    autoScalerProfile Property Map

    Parameters to be applied to the cluster-autoscaler when enabled

    autoUpgradeProfile Property Map

    Profile of auto upgrade configuration.

    disableLocalAccounts Boolean

    If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.

    diskEncryptionSetID String

    ResourceId of the disk encryption set to use for enabling encryption at rest.

    dnsPrefix String

    DNS prefix specified when creating the managed cluster.

    enablePodSecurityPolicy Boolean

    (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.

    enableRBAC Boolean

    Whether to enable Kubernetes Role-Based Access Control.

    extendedLocation Property Map

    The extended location of the Virtual Machine.

    fqdnSubdomain String

    FQDN subdomain specified when creating private cluster with custom private dns zone.

    httpProxyConfig Property Map

    Configurations for provisioning the cluster with HTTP proxy servers.

    identity Property Map

    The identity of the managed cluster, if configured.

    identityProfile Map<Property Map>

    Identities associated with the cluster.

    kubernetesVersion String

    Version of Kubernetes specified when creating the managed cluster.

    linuxProfile Property Map

    Profile for Linux VMs in the container service cluster.

    location String

    Resource location

    networkProfile Property Map

    Profile of network configuration.

    nodeResourceGroup String

    Name of the resource group containing agent pool nodes.

    podIdentityProfile Property Map

    Profile of managed cluster pod identity.

    privateLinkResources List<Property Map>

    Private link resources associated with the cluster.

    resourceName String

    The name of the managed cluster resource.

    servicePrincipalProfile Property Map

    Information about a service principal identity for the cluster to use for manipulating Azure APIs.

    sku Property Map

    The managed cluster SKU.

    tags Map<String>

    Resource tags

    windowsProfile Property Map

    Profile for Windows VMs in the container service cluster.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ManagedCluster resource produces the following output properties:

    AzurePortalFQDN string

    FQDN for the master pool which used by proxy config.

    Fqdn string

    FQDN for the master pool.

    Id string

    The provider-assigned unique ID for this managed resource.

    MaxAgentPools int

    The max number of agent pools for the managed cluster.

    Name string

    Resource name

    PowerState Pulumi.AzureNative.ContainerService.Outputs.PowerStateResponse

    Represents the Power State of the cluster

    PrivateFQDN string

    FQDN of private cluster.

    ProvisioningState string

    The current deployment or provisioning state, which only appears in the response.

    Type string

    Resource type

    AzurePortalFQDN string

    FQDN for the master pool which used by proxy config.

    Fqdn string

    FQDN for the master pool.

    Id string

    The provider-assigned unique ID for this managed resource.

    MaxAgentPools int

    The max number of agent pools for the managed cluster.

    Name string

    Resource name

    PowerState PowerStateResponse

    Represents the Power State of the cluster

    PrivateFQDN string

    FQDN of private cluster.

    ProvisioningState string

    The current deployment or provisioning state, which only appears in the response.

    Type string

    Resource type

    azurePortalFQDN String

    FQDN for the master pool which used by proxy config.

    fqdn String

    FQDN for the master pool.

    id String

    The provider-assigned unique ID for this managed resource.

    maxAgentPools Integer

    The max number of agent pools for the managed cluster.

    name String

    Resource name

    powerState PowerStateResponse

    Represents the Power State of the cluster

    privateFQDN String

    FQDN of private cluster.

    provisioningState String

    The current deployment or provisioning state, which only appears in the response.

    type String

    Resource type

    azurePortalFQDN string

    FQDN for the master pool which used by proxy config.

    fqdn string

    FQDN for the master pool.

    id string

    The provider-assigned unique ID for this managed resource.

    maxAgentPools number

    The max number of agent pools for the managed cluster.

    name string

    Resource name

    powerState PowerStateResponse

    Represents the Power State of the cluster

    privateFQDN string

    FQDN of private cluster.

    provisioningState string

    The current deployment or provisioning state, which only appears in the response.

    type string

    Resource type

    azure_portal_fqdn str

    FQDN for the master pool which used by proxy config.

    fqdn str

    FQDN for the master pool.

    id str

    The provider-assigned unique ID for this managed resource.

    max_agent_pools int

    The max number of agent pools for the managed cluster.

    name str

    Resource name

    power_state PowerStateResponse

    Represents the Power State of the cluster

    private_fqdn str

    FQDN of private cluster.

    provisioning_state str

    The current deployment or provisioning state, which only appears in the response.

    type str

    Resource type

    azurePortalFQDN String

    FQDN for the master pool which used by proxy config.

    fqdn String

    FQDN for the master pool.

    id String

    The provider-assigned unique ID for this managed resource.

    maxAgentPools Number

    The max number of agent pools for the managed cluster.

    name String

    Resource name

    powerState Property Map

    Represents the Power State of the cluster

    privateFQDN String

    FQDN of private cluster.

    provisioningState String

    The current deployment or provisioning state, which only appears in the response.

    type String

    Resource type

    Supporting Types

    AgentPoolMode

    System
    System
    User
    User
    AgentPoolModeSystem
    System
    AgentPoolModeUser
    User
    System
    System
    User
    User
    System
    System
    User
    User
    SYSTEM
    System
    USER
    User
    "System"
    System
    "User"
    User

    AgentPoolType

    VirtualMachineScaleSets
    VirtualMachineScaleSets
    AvailabilitySet
    AvailabilitySet
    AgentPoolTypeVirtualMachineScaleSets
    VirtualMachineScaleSets
    AgentPoolTypeAvailabilitySet
    AvailabilitySet
    VirtualMachineScaleSets
    VirtualMachineScaleSets
    AvailabilitySet
    AvailabilitySet
    VirtualMachineScaleSets
    VirtualMachineScaleSets
    AvailabilitySet
    AvailabilitySet
    VIRTUAL_MACHINE_SCALE_SETS
    VirtualMachineScaleSets
    AVAILABILITY_SET
    AvailabilitySet
    "VirtualMachineScaleSets"
    VirtualMachineScaleSets
    "AvailabilitySet"
    AvailabilitySet

    AgentPoolUpgradeSettings

    MaxSurge string

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    MaxSurge string

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    maxSurge String

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    maxSurge string

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    max_surge str

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    maxSurge String

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    AgentPoolUpgradeSettingsResponse

    MaxSurge string

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    MaxSurge string

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    maxSurge String

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    maxSurge string

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    max_surge str

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    maxSurge String

    Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default

    CloudErrorBodyResponse

    Code string

    An identifier for the error. Codes are invariant and are intended to be consumed programmatically.

    Details List<Pulumi.AzureNative.ContainerService.Inputs.CloudErrorBodyResponse>

    A list of additional details about the error.

    Message string

    A message describing the error, intended to be suitable for display in a user interface.

    Target string

    The target of the particular error. For example, the name of the property in error.

    Code string

    An identifier for the error. Codes are invariant and are intended to be consumed programmatically.

    Details []CloudErrorBodyResponse

    A list of additional details about the error.

    Message string

    A message describing the error, intended to be suitable for display in a user interface.

    Target string

    The target of the particular error. For example, the name of the property in error.

    code String

    An identifier for the error. Codes are invariant and are intended to be consumed programmatically.

    details List<CloudErrorBodyResponse>

    A list of additional details about the error.

    message String

    A message describing the error, intended to be suitable for display in a user interface.

    target String

    The target of the particular error. For example, the name of the property in error.

    code string

    An identifier for the error. Codes are invariant and are intended to be consumed programmatically.

    details CloudErrorBodyResponse[]

    A list of additional details about the error.

    message string

    A message describing the error, intended to be suitable for display in a user interface.

    target string

    The target of the particular error. For example, the name of the property in error.

    code str

    An identifier for the error. Codes are invariant and are intended to be consumed programmatically.

    details Sequence[CloudErrorBodyResponse]

    A list of additional details about the error.

    message str

    A message describing the error, intended to be suitable for display in a user interface.

    target str

    The target of the particular error. For example, the name of the property in error.

    code String

    An identifier for the error. Codes are invariant and are intended to be consumed programmatically.

    details List<Property Map>

    A list of additional details about the error.

    message String

    A message describing the error, intended to be suitable for display in a user interface.

    target String

    The target of the particular error. For example, the name of the property in error.

    CloudErrorResponse

    Error CloudErrorBodyResponse

    Details about the error.

    error CloudErrorBodyResponse

    Details about the error.

    error CloudErrorBodyResponse

    Details about the error.

    error CloudErrorBodyResponse

    Details about the error.

    error Property Map

    Details about the error.

    ContainerServiceLinuxProfile

    AdminUsername string

    The administrator username to use for Linux VMs.

    Ssh Pulumi.AzureNative.ContainerService.Inputs.ContainerServiceSshConfiguration

    SSH configuration for Linux-based VMs running on Azure.

    AdminUsername string

    The administrator username to use for Linux VMs.

    Ssh ContainerServiceSshConfiguration

    SSH configuration for Linux-based VMs running on Azure.

    adminUsername String

    The administrator username to use for Linux VMs.

    ssh ContainerServiceSshConfiguration

    SSH configuration for Linux-based VMs running on Azure.

    adminUsername string

    The administrator username to use for Linux VMs.

    ssh ContainerServiceSshConfiguration

    SSH configuration for Linux-based VMs running on Azure.

    admin_username str

    The administrator username to use for Linux VMs.

    ssh ContainerServiceSshConfiguration

    SSH configuration for Linux-based VMs running on Azure.

    adminUsername String

    The administrator username to use for Linux VMs.

    ssh Property Map

    SSH configuration for Linux-based VMs running on Azure.

    ContainerServiceLinuxProfileResponse

    AdminUsername string

    The administrator username to use for Linux VMs.

    Ssh Pulumi.AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationResponse

    SSH configuration for Linux-based VMs running on Azure.

    AdminUsername string

    The administrator username to use for Linux VMs.

    Ssh ContainerServiceSshConfigurationResponse

    SSH configuration for Linux-based VMs running on Azure.

    adminUsername String

    The administrator username to use for Linux VMs.

    ssh ContainerServiceSshConfigurationResponse

    SSH configuration for Linux-based VMs running on Azure.

    adminUsername string

    The administrator username to use for Linux VMs.

    ssh ContainerServiceSshConfigurationResponse

    SSH configuration for Linux-based VMs running on Azure.

    admin_username str

    The administrator username to use for Linux VMs.

    ssh ContainerServiceSshConfigurationResponse

    SSH configuration for Linux-based VMs running on Azure.

    adminUsername String

    The administrator username to use for Linux VMs.

    ssh Property Map

    SSH configuration for Linux-based VMs running on Azure.

    ContainerServiceNetworkProfile

    DnsServiceIP string

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    DockerBridgeCidr string

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    LoadBalancerProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfile

    Profile of the cluster load balancer.

    LoadBalancerSku string | Pulumi.AzureNative.ContainerService.LoadBalancerSku

    The load balancer sku for the managed cluster.

    NetworkMode string | Pulumi.AzureNative.ContainerService.NetworkMode

    Network mode used for building Kubernetes network.

    NetworkPlugin string | Pulumi.AzureNative.ContainerService.NetworkPlugin

    Network plugin used for building Kubernetes network.

    NetworkPolicy string | Pulumi.AzureNative.ContainerService.NetworkPolicy

    Network policy used for building Kubernetes network.

    OutboundType string | Pulumi.AzureNative.ContainerService.OutboundType

    The outbound (egress) routing method.

    PodCidr string

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    ServiceCidr string

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    DnsServiceIP string

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    DockerBridgeCidr string

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    LoadBalancerProfile ManagedClusterLoadBalancerProfile

    Profile of the cluster load balancer.

    LoadBalancerSku string | LoadBalancerSku

    The load balancer sku for the managed cluster.

    NetworkMode string | NetworkMode

    Network mode used for building Kubernetes network.

    NetworkPlugin string | NetworkPlugin

    Network plugin used for building Kubernetes network.

    NetworkPolicy string | NetworkPolicy

    Network policy used for building Kubernetes network.

    OutboundType string | OutboundType

    The outbound (egress) routing method.

    PodCidr string

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    ServiceCidr string

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dnsServiceIP String

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    dockerBridgeCidr String

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    loadBalancerProfile ManagedClusterLoadBalancerProfile

    Profile of the cluster load balancer.

    loadBalancerSku String | LoadBalancerSku

    The load balancer sku for the managed cluster.

    networkMode String | NetworkMode

    Network mode used for building Kubernetes network.

    networkPlugin String | NetworkPlugin

    Network plugin used for building Kubernetes network.

    networkPolicy String | NetworkPolicy

    Network policy used for building Kubernetes network.

    outboundType String | OutboundType

    The outbound (egress) routing method.

    podCidr String

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    serviceCidr String

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dnsServiceIP string

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    dockerBridgeCidr string

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    loadBalancerProfile ManagedClusterLoadBalancerProfile

    Profile of the cluster load balancer.

    loadBalancerSku string | LoadBalancerSku

    The load balancer sku for the managed cluster.

    networkMode string | NetworkMode

    Network mode used for building Kubernetes network.

    networkPlugin string | NetworkPlugin

    Network plugin used for building Kubernetes network.

    networkPolicy string | NetworkPolicy

    Network policy used for building Kubernetes network.

    outboundType string | OutboundType

    The outbound (egress) routing method.

    podCidr string

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    serviceCidr string

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dns_service_ip str

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    docker_bridge_cidr str

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    load_balancer_profile ManagedClusterLoadBalancerProfile

    Profile of the cluster load balancer.

    load_balancer_sku str | LoadBalancerSku

    The load balancer sku for the managed cluster.

    network_mode str | NetworkMode

    Network mode used for building Kubernetes network.

    network_plugin str | NetworkPlugin

    Network plugin used for building Kubernetes network.

    network_policy str | NetworkPolicy

    Network policy used for building Kubernetes network.

    outbound_type str | OutboundType

    The outbound (egress) routing method.

    pod_cidr str

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    service_cidr str

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dnsServiceIP String

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    dockerBridgeCidr String

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    loadBalancerProfile Property Map

    Profile of the cluster load balancer.

    loadBalancerSku String | "standard" | "basic"

    The load balancer sku for the managed cluster.

    networkMode String | "transparent" | "bridge"

    Network mode used for building Kubernetes network.

    networkPlugin String | "azure" | "kubenet"

    Network plugin used for building Kubernetes network.

    networkPolicy String | "calico" | "azure"

    Network policy used for building Kubernetes network.

    outboundType String | "loadBalancer" | "userDefinedRouting"

    The outbound (egress) routing method.

    podCidr String

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    serviceCidr String

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    ContainerServiceNetworkProfileResponse

    DnsServiceIP string

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    DockerBridgeCidr string

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    LoadBalancerProfile Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileResponse

    Profile of the cluster load balancer.

    LoadBalancerSku string

    The load balancer sku for the managed cluster.

    NetworkMode string

    Network mode used for building Kubernetes network.

    NetworkPlugin string

    Network plugin used for building Kubernetes network.

    NetworkPolicy string

    Network policy used for building Kubernetes network.

    OutboundType string

    The outbound (egress) routing method.

    PodCidr string

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    ServiceCidr string

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    DnsServiceIP string

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    DockerBridgeCidr string

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    LoadBalancerProfile ManagedClusterLoadBalancerProfileResponse

    Profile of the cluster load balancer.

    LoadBalancerSku string

    The load balancer sku for the managed cluster.

    NetworkMode string

    Network mode used for building Kubernetes network.

    NetworkPlugin string

    Network plugin used for building Kubernetes network.

    NetworkPolicy string

    Network policy used for building Kubernetes network.

    OutboundType string

    The outbound (egress) routing method.

    PodCidr string

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    ServiceCidr string

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dnsServiceIP String

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    dockerBridgeCidr String

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    loadBalancerProfile ManagedClusterLoadBalancerProfileResponse

    Profile of the cluster load balancer.

    loadBalancerSku String

    The load balancer sku for the managed cluster.

    networkMode String

    Network mode used for building Kubernetes network.

    networkPlugin String

    Network plugin used for building Kubernetes network.

    networkPolicy String

    Network policy used for building Kubernetes network.

    outboundType String

    The outbound (egress) routing method.

    podCidr String

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    serviceCidr String

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dnsServiceIP string

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    dockerBridgeCidr string

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    loadBalancerProfile ManagedClusterLoadBalancerProfileResponse

    Profile of the cluster load balancer.

    loadBalancerSku string

    The load balancer sku for the managed cluster.

    networkMode string

    Network mode used for building Kubernetes network.

    networkPlugin string

    Network plugin used for building Kubernetes network.

    networkPolicy string

    Network policy used for building Kubernetes network.

    outboundType string

    The outbound (egress) routing method.

    podCidr string

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    serviceCidr string

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dns_service_ip str

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    docker_bridge_cidr str

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    load_balancer_profile ManagedClusterLoadBalancerProfileResponse

    Profile of the cluster load balancer.

    load_balancer_sku str

    The load balancer sku for the managed cluster.

    network_mode str

    Network mode used for building Kubernetes network.

    network_plugin str

    Network plugin used for building Kubernetes network.

    network_policy str

    Network policy used for building Kubernetes network.

    outbound_type str

    The outbound (egress) routing method.

    pod_cidr str

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    service_cidr str

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    dnsServiceIP String

    An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.

    dockerBridgeCidr String

    A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.

    loadBalancerProfile Property Map

    Profile of the cluster load balancer.

    loadBalancerSku String

    The load balancer sku for the managed cluster.

    networkMode String

    Network mode used for building Kubernetes network.

    networkPlugin String

    Network plugin used for building Kubernetes network.

    networkPolicy String

    Network policy used for building Kubernetes network.

    outboundType String

    The outbound (egress) routing method.

    podCidr String

    A CIDR notation IP range from which to assign pod IPs when kubenet is used.

    serviceCidr String

    A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.

    ContainerServiceSshConfiguration

    PublicKeys List<Pulumi.AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKey>

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    PublicKeys []ContainerServiceSshPublicKey

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    publicKeys List<ContainerServiceSshPublicKey>

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    publicKeys ContainerServiceSshPublicKey[]

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    public_keys Sequence[ContainerServiceSshPublicKey]

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    publicKeys List<Property Map>

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    ContainerServiceSshConfigurationResponse

    PublicKeys List<Pulumi.AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyResponse>

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    PublicKeys []ContainerServiceSshPublicKeyResponse

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    publicKeys List<ContainerServiceSshPublicKeyResponse>

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    publicKeys ContainerServiceSshPublicKeyResponse[]

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    public_keys Sequence[ContainerServiceSshPublicKeyResponse]

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    publicKeys List<Property Map>

    The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.

    ContainerServiceSshPublicKey

    KeyData string

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    KeyData string

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    keyData String

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    keyData string

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    key_data str

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    keyData String

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    ContainerServiceSshPublicKeyResponse

    KeyData string

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    KeyData string

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    keyData String

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    keyData string

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    key_data str

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    keyData String

    Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.

    Expander

    Least_waste
    least-waste
    Most_pods
    most-pods
    Priority
    priority
    Random
    random
    Expander_Least_Waste
    least-waste
    Expander_Most_Pods
    most-pods
    ExpanderPriority
    priority
    ExpanderRandom
    random
    Leastwaste
    least-waste
    Mostpods
    most-pods
    Priority
    priority
    Random
    random
    Least_waste
    least-waste
    Most_pods
    most-pods
    Priority
    priority
    Random
    random
    LEAST_WASTE
    least-waste
    MOST_PODS
    most-pods
    PRIORITY
    priority
    RANDOM
    random
    "least-waste"
    least-waste
    "most-pods"
    most-pods
    "priority"
    priority
    "random"
    random

    ExtendedLocation

    Name string

    The name of the extended location.