Azure Native

v1.88.1 published on Thursday, Dec 1, 2022 by Pulumi

ManagedCluster

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

Example Usage

Create Managed Cluster with Azure KeyVault Secrets Provider Addon

using System.Collections.Generic;
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=[{
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "Standard_DS2_v2",
    }],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileResponseArgs(
        admin_username="azureuser",
        ssh={
            "publicKeys": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableEncryptionAtHost": True,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "Standard_DS2_v2",
    }],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileResponseArgs(
        admin_username="azureuser",
        ssh={
            "publicKeys": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableFIPS": True,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "Standard_DS2_v2",
    }],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=False,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileResponseArgs(
        admin_username="azureuser",
        ssh={
            "publicKeys": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableNodePublicIP": True,
        "gpuInstanceProfile": "MIG3g",
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "Standard_DS2_v2",
    }],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "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",
    }],
    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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osSKU": "CBLMariner",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "Standard_DS2_v2",
    }],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "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",
    }],
    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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "Standard_DS2_v2",
    }],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileResponseArgs(
        admin_username="azureuser",
        ssh={
            "publicKeys": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "count": 3,
        "enableEncryptionAtHost": True,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "availabilityZones": [
            "1",
            "2",
            "3",
        ],
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "availabilityZones": [
            "1",
            "2",
            "3",
        ],
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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 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=[{
        "availabilityZones": [
            "1",
            "2",
            "3",
        ],
        "count": 3,
        "enableNodePublicIP": True,
        "mode": "System",
        "name": "nodepool1",
        "osType": "Linux",
        "type": "VirtualMachineScaleSets",
        "vmSize": "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": [{
                "keyData": "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.ManagedClusterServicePrincipalProfileResponseArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileResponseArgs(
        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.

Type string | Pulumi.AzureNative.ContainerService.ExtendedLocationTypes

The type of the extended location.

Name string

The name of the extended location.

Type string | ExtendedLocationTypes

The type of the extended location.

name String

The name of the extended location.

type String | ExtendedLocationTypes

The type of the extended location.

name string

The name of the extended location.

type string | ExtendedLocationTypes

The type of the extended location.

name str

The name of the extended location.

type str | ExtendedLocationTypes

The type of the extended location.

name String

The name of the extended location.

type String | "EdgeZone"

The type of the extended location.

ExtendedLocationResponse

Name string

The name of the extended location.

Type string

The type of the extended location.

Name string

The name of the extended location.

Type string

The type of the extended location.

name String

The name of the extended location.

type String

The type of the extended location.

name string

The name of the extended location.