ManagedCluster

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

Example Usage

Create Managed Cluster with Azure KeyVault Secrets Provider Addon

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = 
            {
                { "azureKeyvaultSecretsProvider", new AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileArgs
                {
                    Config = 
                    {
                        { "enableSecretRotation", "true" },
                    },
                    Enabled = true,
                } },
            },
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: containerservice.ManagedClusterAddonProfileMap{
				"azureKeyvaultSecretsProvider": &containerservice.ManagedClusterAddonProfileArgs{
					Config: pulumi.StringMap{
						"enableSecretRotation": pulumi.String("true"),
					},
					Enabled: pulumi.Bool(true),
				},
			},
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={
        "azureKeyvaultSecretsProvider": azure_native.containerservice.ManagedClusterAddonProfileArgs(
            config={
                "enableSecretRotation": "true",
            },
            enabled=True,
        ),
    },
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {
        azureKeyvaultSecretsProvider: {
            config: {
                enableSecretRotation: "true",
            },
            enabled: true,
        },
    },
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with EncryptionAtHost enabled

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:                  pulumi.Int(3),
					EnableEncryptionAtHost: pulumi.Bool(true),
					EnableNodePublicIP:     pulumi.Bool(true),
					Mode:                   pulumi.String("System"),
					Name:                   pulumi.String("nodepool1"),
					OsType:                 pulumi.String("Linux"),
					Type:                   pulumi.String("VirtualMachineScaleSets"),
					VmSize:                 pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_encryption_at_host=True,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableEncryptionAtHost: true,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with FIPS enabled OS

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableFIPS:         pulumi.Bool(true),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(false),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_fips=True,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=False,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableFIPS: true,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: false,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with GPUMIG

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 = 
                {
                    "localhost",
                    "127.0.0.1",
                },
                TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = 
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					GpuInstanceProfile: pulumi.String("MIG3g"),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_ND96asr_v4"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
				HttpProxy:  pulumi.String("http://myproxy.server.com:8080"),
				HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
				NoProxy: pulumi.StringArray{
					pulumi.String("localhost"),
					pulumi.String("127.0.0.1"),
				},
				TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
			},
			KubernetesVersion: pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        gpu_instance_profile="MIG3g",
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_ND96asr_v4",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
        http_proxy="http://myproxy.server.com:8080",
        https_proxy="https://myproxy.server.com:8080",
        no_proxy=[
            "localhost",
            "127.0.0.1",
        ],
        trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
    ),
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        gpuInstanceProfile: "MIG3g",
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_ND96asr_v4",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    httpProxyConfig: {
        httpProxy: "http://myproxy.server.com:8080",
        httpsProxy: "https://myproxy.server.com:8080",
        noProxy: [
            "localhost",
            "127.0.0.1",
        ],
        trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
    },
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with HTTP proxy configured

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 = 
                {
                    "localhost",
                    "127.0.0.1",
                },
                TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = 
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
				HttpProxy:  pulumi.String("http://myproxy.server.com:8080"),
				HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
				NoProxy: pulumi.StringArray{
					pulumi.String("localhost"),
					pulumi.String("127.0.0.1"),
				},
				TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
			},
			KubernetesVersion: pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
        http_proxy="http://myproxy.server.com:8080",
        https_proxy="https://myproxy.server.com:8080",
        no_proxy=[
            "localhost",
            "127.0.0.1",
        ],
        trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
    ),
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    httpProxyConfig: {
        httpProxy: "http://myproxy.server.com:8080",
        httpsProxy: "https://myproxy.server.com:8080",
        noProxy: [
            "localhost",
            "127.0.0.1",
        ],
        trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
    },
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with Node Public IP Prefix

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:                pulumi.Int(3),
					EnableNodePublicIP:   pulumi.Bool(true),
					Mode:                 pulumi.String("System"),
					Name:                 pulumi.String("nodepool1"),
					NodePublicIPPrefixID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
					OsType:               pulumi.String("Linux"),
					Type:                 pulumi.String("VirtualMachineScaleSets"),
					VmSize:               pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        node_public_ip_prefix_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        nodePublicIPPrefixID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with OSSKU

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 = 
                {
                    "localhost",
                    "127.0.0.1",
                },
                TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = 
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsSKU:              pulumi.String("CBLMariner"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
				HttpProxy:  pulumi.String("http://myproxy.server.com:8080"),
				HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
				NoProxy: pulumi.StringArray{
					pulumi.String("localhost"),
					pulumi.String("127.0.0.1"),
				},
				TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
			},
			KubernetesVersion: pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_sku="CBLMariner",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
        http_proxy="http://myproxy.server.com:8080",
        https_proxy="https://myproxy.server.com:8080",
        no_proxy=[
            "localhost",
            "127.0.0.1",
        ],
        trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
    ),
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osSKU: "CBLMariner",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    httpProxyConfig: {
        httpProxy: "http://myproxy.server.com:8080",
        httpsProxy: "https://myproxy.server.com:8080",
        noProxy: [
            "localhost",
            "127.0.0.1",
        ],
        trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
    },
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with PPG

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:                     pulumi.Int(3),
					EnableNodePublicIP:        pulumi.Bool(true),
					Mode:                      pulumi.String("System"),
					Name:                      pulumi.String("nodepool1"),
					OsType:                    pulumi.String("Linux"),
					ProximityPlacementGroupID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1"),
					Type:                      pulumi.String("VirtualMachineScaleSets"),
					VmSize:                    pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        proximity_placement_group_id="/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        proximityPlacementGroupID: "/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Cluster with PodIdentity enabled

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            PodIdentityProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityProfileArgs
            {
                AllowNetworkPluginKubenet = true,
                Enabled = true,
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			PodIdentityProfile: &containerservice.ManagedClusterPodIdentityProfileArgs{
				AllowNetworkPluginKubenet: pulumi.Bool(true),
				Enabled:                   pulumi.Bool(true),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    pod_identity_profile=azure_native.containerservice.ManagedClusterPodIdentityProfileArgs(
        allow_network_plugin_kubenet=True,
        enabled=True,
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    podIdentityProfile: {
        allowNetworkPluginKubenet: true,
        enabled: true,
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create Managed Private Cluster with fqdn subdomain specified

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:                  pulumi.Int(3),
					EnableEncryptionAtHost: pulumi.Bool(true),
					EnableNodePublicIP:     pulumi.Bool(true),
					Mode:                   pulumi.String("System"),
					Name:                   pulumi.String("nodepool1"),
					OsType:                 pulumi.String("Linux"),
					Type:                   pulumi.String("VirtualMachineScaleSets"),
					VmSize:                 pulumi.String("Standard_DS2_v2"),
				},
			},
			ApiServerAccessProfile: &containerservice.ManagedClusterAPIServerAccessProfileArgs{
				EnablePrivateCluster: pulumi.Bool(true),
				PrivateDNSZone:       pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io"),
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			FqdnSubdomain:           pulumi.String("domain1"),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        count=3,
        enable_encryption_at_host=True,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS2_v2",
    )],
    api_server_access_profile=azure_native.containerservice.ManagedClusterAPIServerAccessProfileArgs(
        enable_private_cluster=True,
        private_dns_zone="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
    ),
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    enable_pod_security_policy=True,
    enable_rbac=True,
    fqdn_subdomain="domain1",
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableEncryptionAtHost: true,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    apiServerAccessProfile: {
        enablePrivateCluster: true,
        privateDNSZone: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
    },
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    fqdnSubdomain: "domain1",
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create/Update AAD Managed Cluster with EnableAzureRBAC

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AadProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAADProfileArgs
            {
                EnableAzureRBAC = true,
                Managed = true,
            },
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    AvailabilityZones = 
                    {
                        "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 AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AadProfile: &containerservice.ManagedClusterAADProfileArgs{
				EnableAzureRBAC: pulumi.Bool(true),
				Managed:         pulumi.Bool(true),
			},
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					AvailabilityZones: pulumi.StringArray{
						pulumi.String("1"),
						pulumi.String("2"),
						pulumi.String("3"),
					},
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS1_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    aad_profile=azure_native.containerservice.ManagedClusterAADProfileArgs(
        enable_azure_rbac=True,
        managed=True,
    ),
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        availability_zones=[
            "1",
            "2",
            "3",
        ],
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS1_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    aadProfile: {
        enableAzureRBAC: true,
        managed: true,
    },
    addonProfiles: {},
    agentPoolProfiles: [{
        availabilityZones: [
            "1",
            "2",
            "3",
        ],
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS1_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: "standard",
        outboundType: "loadBalancer",
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: `replacePassword1234$`,
        adminUsername: "azureuser",
    },
});

Create/Update Managed Cluster

using Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    AvailabilityZones = 
                    {
                        "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 = "UserAssigned",
                UserAssignedIdentities = 
                {
                    { "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1",  },
                },
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = 
                    {
                        new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                        {
                            KeyData = "keydata",
                        },
                    },
                },
            },
            Location = "location1",
            NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
            {
                LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
                {
                    ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                    {
                        Count = 2,
                    },
                },
                LoadBalancerSku = "standard",
                OutboundType = "loadBalancer",
            },
            ResourceGroupName = "rg1",
            ResourceName = "clustername1",
            ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
            {
                ClientId = "clientid",
                Secret = "secret",
            },
            Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
            {
                Name = "Basic",
                Tier = "Free",
            },
            Tags = 
            {
                { "archv2", "" },
                { "tier", "production" },
            },
            WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
            {
                AdminPassword = "replacePassword1234$",
                AdminUsername = "azureuser",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					AvailabilityZones: pulumi.StringArray{
						pulumi.String("1"),
						pulumi.String("2"),
						pulumi.String("3"),
					},
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS1_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				BalanceSimilarNodeGroups: pulumi.String("true"),
				Expander:                 pulumi.String("priority"),
				MaxNodeProvisionTime:     pulumi.String("15m"),
				NewPodScaleUpDelay:       pulumi.String("1m"),
				ScaleDownDelayAfterAdd:   pulumi.String("15m"),
				ScanInterval:             pulumi.String("20s"),
				SkipNodesWithSystemPods:  pulumi.String("false"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			Identity: &containerservice.ManagedClusterIdentityArgs{
				Type: "UserAssigned",
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": nil,
				},
			},
			KubernetesVersion: pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        availability_zones=[
            "1",
            "2",
            "3",
        ],
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS1_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        balance_similar_node_groups="true",
        expander="priority",
        max_node_provision_time="15m",
        new_pod_scale_up_delay="1m",
        scale_down_delay_after_add="15m",
        scan_interval="20s",
        skip_nodes_with_system_pods="false",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    identity=azure_native.containerservice.ManagedClusterIdentityArgs(
        type="UserAssigned",
        user_assigned_identities={
            "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
        },
    ),
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        availabilityZones: [
            "1",
            "2",
            "3",
        ],
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS1_v2",
    }],
    autoScalerProfile: {
        balanceSimilarNodeGroups: "true",
        expander: "priority",
        maxNodeProvisionTime: "15m",
        newPodScaleUpDelay: "1m",
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
        skipNodesWithSystemPods: "false",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    identity: {
        type: "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 Pulumi;
using AzureNative = Pulumi.AzureNative;

class MyStack : Stack
{
    public MyStack()
    {
        var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new AzureNative.ContainerService.ManagedClusterArgs
        {
            AddonProfiles = ,
            AgentPoolProfiles = 
            {
                new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
                {
                    AvailabilityZones = 
                    {
                        "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 = "UserAssigned",
                UserAssignedIdentities = 
                {
                    { "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1",  },
                },
            },
            KubernetesVersion = "",
            LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
            {
                AdminUsername = "azureuser",
                Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
                {
                    PublicKeys = 
                    {
                        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",
            },
        });
    }

}

package main

import (
	"fmt"

	containerservice "github.com/pulumi/pulumi-azure-native/sdk/go/azure/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: nil,
			AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					AvailabilityZones: pulumi.StringArray{
						pulumi.String("1"),
						pulumi.String("2"),
						pulumi.String("3"),
					},
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(true),
					Mode:               pulumi.String("System"),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String("Linux"),
					Type:               pulumi.String("VirtualMachineScaleSets"),
					VmSize:             pulumi.String("Standard_DS1_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			Identity: &containerservice.ManagedClusterIdentityArgs{
				Type: "UserAssigned",
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": nil,
				},
			},
			KubernetesVersion: pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: []containerservice.ContainerServiceSshPublicKeyArgs{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String("standard"),
				OutboundType:    pulumi.String("loadBalancer"),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String("Free"),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String(fmt.Sprintf("%v%v", "replacePassword1234", "$")),
				AdminUsername: pulumi.String("azureuser"),
				LicenseType:   pulumi.String("Windows_Server"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
        availability_zones=[
            "1",
            "2",
            "3",
        ],
        count=3,
        enable_node_public_ip=True,
        mode="System",
        name="nodepool1",
        os_type="Linux",
        type="VirtualMachineScaleSets",
        vm_size="Standard_DS1_v2",
    )],
    auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
        scale_down_delay_after_add="15m",
        scan_interval="20s",
    ),
    disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    identity=azure_native.containerservice.ManagedClusterIdentityArgs(
        type="UserAssigned",
        user_assigned_identities={
            "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
        },
    ),
    kubernetes_version="",
    linux_profile=azure_native.containerservice.ContainerServiceLinuxProfileArgs(
        admin_username="azureuser",
        ssh=azure_native.containerservice.ContainerServiceSshConfigurationArgs(
            public_keys=[azure_native.containerservice.ContainerServiceSshPublicKeyArgs(
                key_data="keydata",
            )],
        ),
    ),
    location="location1",
    network_profile=azure_native.containerservice.ContainerServiceNetworkProfileArgs(
        load_balancer_profile=azure_native.containerservice.ManagedClusterLoadBalancerProfileArgs(
            managed_outbound_ips=azure_native.containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs(
                count=2,
            ),
        ),
        load_balancer_sku="standard",
        outbound_type="loadBalancer",
    ),
    resource_group_name="rg1",
    resource_name="clustername1",
    service_principal_profile=azure_native.containerservice.ManagedClusterServicePrincipalProfileArgs(
        client_id="clientid",
        secret="secret",
    ),
    sku=azure_native.containerservice.ManagedClusterSKUArgs(
        name="Basic",
        tier="Free",
    ),
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile=azure_native.containerservice.ManagedClusterWindowsProfileArgs(
        admin_password="replacePassword1234$",
        admin_username="azureuser",
        license_type="Windows_Server",
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        availabilityZones: [
            "1",
            "2",
            "3",
        ],
        count: 3,
        enableNodePublicIP: true,
        mode: "System",
        name: "nodepool1",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS1_v2",
    }],
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    identity: {
        type: "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 a 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)
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.

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 {[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.

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 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

Supporting Types

AgentPoolMode

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

AgentPoolType

VirtualMachineScaleSets
VirtualMachineScaleSets
AvailabilitySet
AvailabilitySet
AgentPoolTypeVirtualMachineScaleSets
VirtualMachineScaleSets
AgentPoolTypeAvailabilitySet
AvailabilitySet
VirtualMachineScaleSets
VirtualMachineScaleSets
AvailabilitySet
AvailabilitySet
VIRTUAL_MACHINE_SCALE_SETS
VirtualMachineScaleSets
AVAILABILITY_SET
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
max_surge str
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
max_surge str
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 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.

CloudErrorResponse

Error Pulumi.AzureNative.ContainerService.Inputs.CloudErrorBodyResponse
Details about the error.
Error CloudErrorBodyResponse
Details about the error.
error CloudErrorBodyResponse
Details about the error.
error CloudErrorBodyResponse
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.
admin_username str
The administrator username to use for Linux VMs.
ssh ContainerServiceSshConfiguration
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.
admin_username str
The administrator username to use for Linux VMs.
ssh ContainerServiceSshConfigurationResponse
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.
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.

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.
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.

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 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.

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 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.

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.
key_data str
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.
key_data str
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
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 str
The name of the extended location.
type str | ExtendedLocationTypes
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 str
The name of the extended location.
type str
The type of the extended location.

ExtendedLocationTypes

EdgeZone
EdgeZone
ExtendedLocationTypesEdgeZone
EdgeZone
EdgeZone
EdgeZone
EDGE_ZONE
EdgeZone

GPUInstanceProfile

MIG1g
MIG1g
MIG2g
MIG2g
MIG3g
MIG3g
MIG4g
MIG4g
MIG7g
MIG7g
GPUInstanceProfileMIG1g
MIG1g
GPUInstanceProfileMIG2g
MIG2g
GPUInstanceProfileMIG3g
MIG3g
GPUInstanceProfileMIG4g
MIG4g
GPUInstanceProfileMIG7g
MIG7g
MIG1g
MIG1g
MIG2g
MIG2g
MIG3g
MIG3g
MIG4g
MIG4g
MIG7g
MIG7g
MIG1G
MIG1g
MIG2G
MIG2g
MIG3G
MIG3g
MIG4G
MIG4g
MIG7G
MIG7g

KubeletConfig

AllowedUnsafeSysctls List<string>
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
ContainerLogMaxFiles int
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
ContainerLogMaxSizeMB int
The maximum size (e.g. 10Mi) of container log file before it is rotated.
CpuCfsQuota bool
Enable CPU CFS quota enforcement for containers that specify CPU limits.
CpuCfsQuotaPeriod string
Sets CPU CFS quota period value.
CpuManagerPolicy string
CPU Manager policy to use.
FailSwapOn bool
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
ImageGcHighThreshold int
The percent of disk usage after which image garbage collection is always run.
ImageGcLowThreshold int
The percent of disk usage before which image garbage collection is never run.
PodMaxPids int
The maximum number of processes per pod.
TopologyManagerPolicy string
Topology Manager policy to use.
AllowedUnsafeSysctls []string
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
ContainerLogMaxFiles int
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
ContainerLogMaxSizeMB int
The maximum size (e.g. 10Mi) of container log file before it is rotated.
CpuCfsQuota bool
Enable CPU CFS quota enforcement for containers that specify CPU limits.
CpuCfsQuotaPeriod string
Sets CPU CFS quota period value.
CpuManagerPolicy string
CPU Manager policy to use.
FailSwapOn bool
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
ImageGcHighThreshold int
The percent of disk usage after which image garbage collection is always run.
ImageGcLowThreshold int
The percent of disk usage before which image garbage collection is never run.
PodMaxPids int
The maximum number of processes per pod.
TopologyManagerPolicy string
Topology Manager policy to use.
allowedUnsafeSysctls string[]
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
containerLogMaxFiles number
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
containerLogMaxSizeMB number
The maximum size (e.g. 10Mi) of container log file before it is rotated.
cpuCfsQuota boolean
Enable CPU CFS quota enforcement for containers that specify CPU limits.
cpuCfsQuotaPeriod string
Sets CPU CFS quota period value.
cpuManagerPolicy string
CPU Manager policy to use.
failSwapOn boolean
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
imageGcHighThreshold number
The percent of disk usage after which image garbage collection is always run.
imageGcLowThreshold number
The percent of disk usage before which image garbage collection is never run.
podMaxPids number
The maximum number of processes per pod.
topologyManagerPolicy string
Topology Manager policy to use.
allowed_unsafe_sysctls Sequence[str]
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
container_log_max_files int
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
container_log_max_size_mb int
The maximum size (e.g. 10Mi) of container log file before it is rotated.
cpu_cfs_quota bool
Enable CPU CFS quota enforcement for containers that specify CPU limits.
cpu_cfs_quota_period str
Sets CPU CFS quota period value.
cpu_manager_policy str
CPU Manager policy to use.
fail_swap_on bool
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
image_gc_high_threshold int
The percent of disk usage after which image garbage collection is always run.
image_gc_low_threshold int
The percent of disk usage before which image garbage collection is never run.
pod_max_pids int
The maximum number of processes per pod.
topology_manager_policy str
Topology Manager policy to use.

KubeletConfigResponse

AllowedUnsafeSysctls List<string>
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
ContainerLogMaxFiles int
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
ContainerLogMaxSizeMB int
The maximum size (e.g. 10Mi) of container log file before it is rotated.
CpuCfsQuota bool
Enable CPU CFS quota enforcement for containers that specify CPU limits.
CpuCfsQuotaPeriod string
Sets CPU CFS quota period value.
CpuManagerPolicy string
CPU Manager policy to use.
FailSwapOn bool
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
ImageGcHighThreshold int
The percent of disk usage after which image garbage collection is always run.
ImageGcLowThreshold int
The percent of disk usage before which image garbage collection is never run.
PodMaxPids int
The maximum number of processes per pod.
TopologyManagerPolicy string
Topology Manager policy to use.
AllowedUnsafeSysctls []string
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
ContainerLogMaxFiles int
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
ContainerLogMaxSizeMB int
The maximum size (e.g. 10Mi) of container log file before it is rotated.
CpuCfsQuota bool
Enable CPU CFS quota enforcement for containers that specify CPU limits.
CpuCfsQuotaPeriod string
Sets CPU CFS quota period value.
CpuManagerPolicy string
CPU Manager policy to use.
FailSwapOn bool
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
ImageGcHighThreshold int
The percent of disk usage after which image garbage collection is always run.
ImageGcLowThreshold int
The percent of disk usage before which image garbage collection is never run.
PodMaxPids int
The maximum number of processes per pod.
TopologyManagerPolicy string
Topology Manager policy to use.
allowedUnsafeSysctls string[]
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
containerLogMaxFiles number
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
containerLogMaxSizeMB number
The maximum size (e.g. 10Mi) of container log file before it is rotated.
cpuCfsQuota boolean
Enable CPU CFS quota enforcement for containers that specify CPU limits.
cpuCfsQuotaPeriod string
Sets CPU CFS quota period value.
cpuManagerPolicy string
CPU Manager policy to use.
failSwapOn boolean
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
imageGcHighThreshold number
The percent of disk usage after which image garbage collection is always run.
imageGcLowThreshold number
The percent of disk usage before which image garbage collection is never run.
podMaxPids number
The maximum number of processes per pod.
topologyManagerPolicy string
Topology Manager policy to use.
allowed_unsafe_sysctls Sequence[str]
Allowlist of unsafe sysctls or unsafe sysctl patterns (ending in *).
container_log_max_files int
The maximum number of container log files that can be present for a container. The number must be ≥ 2.
container_log_max_size_mb int
The maximum size (e.g. 10Mi) of container log file before it is rotated.
cpu_cfs_quota bool
Enable CPU CFS quota enforcement for containers that specify CPU limits.
cpu_cfs_quota_period str
Sets CPU CFS quota period value.
cpu_manager_policy str
CPU Manager policy to use.
fail_swap_on bool
If set to true it will make the Kubelet fail to start if swap is enabled on the node.
image_gc_high_threshold int
The percent of disk usage after which image garbage collection is always run.
image_gc_low_threshold int
The percent of disk usage before which image garbage collection is never run.
pod_max_pids int
The maximum number of processes per pod.
topology_manager_policy str
Topology Manager policy to use.

KubeletDiskType

OS
OS
Temporary
Temporary
KubeletDiskTypeOS
OS
KubeletDiskTypeTemporary
Temporary
OS
OS
Temporary
Temporary
OS
OS
TEMPORARY
Temporary

LicenseType

None
None
Windows_Server
Windows_Server
LicenseTypeNone
None
LicenseType_Windows_Server
Windows_Server
None
None
Windows_Server
Windows_Server
NONE
None
WINDOWS_SERVER
Windows_Server

LinuxOSConfig

SwapFileSizeMB int
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
Sysctls Pulumi.AzureNative.ContainerService.Inputs.SysctlConfig
Sysctl settings for Linux agent nodes.
TransparentHugePageDefrag string
Transparent Huge Page defrag configuration.
TransparentHugePageEnabled string
Transparent Huge Page enabled configuration.
SwapFileSizeMB int
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
Sysctls SysctlConfig
Sysctl settings for Linux agent nodes.
TransparentHugePageDefrag string
Transparent Huge Page defrag configuration.
TransparentHugePageEnabled string
Transparent Huge Page enabled configuration.
swapFileSizeMB number
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
sysctls SysctlConfig
Sysctl settings for Linux agent nodes.
transparentHugePageDefrag string
Transparent Huge Page defrag configuration.
transparentHugePageEnabled string
Transparent Huge Page enabled configuration.
swap_file_size_mb int
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
sysctls SysctlConfig
Sysctl settings for Linux agent nodes.
transparent_huge_page_defrag str
Transparent Huge Page defrag configuration.
transparent_huge_page_enabled str
Transparent Huge Page enabled configuration.

LinuxOSConfigResponse

SwapFileSizeMB int
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
Sysctls Pulumi.AzureNative.ContainerService.Inputs.SysctlConfigResponse
Sysctl settings for Linux agent nodes.
TransparentHugePageDefrag string
Transparent Huge Page defrag configuration.
TransparentHugePageEnabled string
Transparent Huge Page enabled configuration.
SwapFileSizeMB int
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
Sysctls SysctlConfigResponse
Sysctl settings for Linux agent nodes.
TransparentHugePageDefrag string
Transparent Huge Page defrag configuration.
TransparentHugePageEnabled string
Transparent Huge Page enabled configuration.
swapFileSizeMB number
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
sysctls SysctlConfigResponse
Sysctl settings for Linux agent nodes.
transparentHugePageDefrag string
Transparent Huge Page defrag configuration.
transparentHugePageEnabled string
Transparent Huge Page enabled configuration.
swap_file_size_mb int
SwapFileSizeMB specifies size in MB of a swap file will be created on each node.
sysctls SysctlConfigResponse
Sysctl settings for Linux agent nodes.
transparent_huge_page_defrag str
Transparent Huge Page defrag configuration.
transparent_huge_page_enabled str
Transparent Huge Page enabled configuration.

LoadBalancerSku

Standard
standard
Basic
basic
LoadBalancerSkuStandard
standard
LoadBalancerSkuBasic
basic
Standard
standard
Basic
basic
STANDARD
standard
BASIC
basic

ManagedClusterAADProfile

AdminGroupObjectIDs List<string>
AAD group object IDs that will have admin role of the cluster.
ClientAppID string
The client AAD application ID.
EnableAzureRBAC bool
Whether to enable Azure RBAC for Kubernetes authorization.
Managed bool
Whether to enable managed AAD.
ServerAppID string
The server AAD application ID.
ServerAppSecret string
The server AAD application secret.
TenantID string
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
AdminGroupObjectIDs []string
AAD group object IDs that will have admin role of the cluster.
ClientAppID string
The client AAD application ID.
EnableAzureRBAC bool
Whether to enable Azure RBAC for Kubernetes authorization.
Managed bool
Whether to enable managed AAD.
ServerAppID string
The server AAD application ID.
ServerAppSecret string
The server AAD application secret.
TenantID string
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
adminGroupObjectIDs string[]
AAD group object IDs that will have admin role of the cluster.
clientAppID string
The client AAD application ID.
enableAzureRBAC boolean
Whether to enable Azure RBAC for Kubernetes authorization.
managed boolean
Whether to enable managed AAD.
serverAppID string
The server AAD application ID.
serverAppSecret string
The server AAD application secret.
tenantID string
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
admin_group_object_ids Sequence[str]
AAD group object IDs that will have admin role of the cluster.
client_app_id str
The client AAD application ID.
enable_azure_rbac bool
Whether to enable Azure RBAC for Kubernetes authorization.
managed bool
Whether to enable managed AAD.
server_app_id str
The server AAD application ID.
server_app_secret str
The server AAD application secret.
tenant_id str
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.

ManagedClusterAADProfileResponse

AdminGroupObjectIDs List<string>
AAD group object IDs that will have admin role of the cluster.
ClientAppID string
The client AAD application ID.
EnableAzureRBAC bool
Whether to enable Azure RBAC for Kubernetes authorization.
Managed bool
Whether to enable managed AAD.
ServerAppID string
The server AAD application ID.
ServerAppSecret string
The server AAD application secret.
TenantID string
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
AdminGroupObjectIDs []string
AAD group object IDs that will have admin role of the cluster.
ClientAppID string
The client AAD application ID.
EnableAzureRBAC bool
Whether to enable Azure RBAC for Kubernetes authorization.
Managed bool
Whether to enable managed AAD.
ServerAppID string
The server AAD application ID.
ServerAppSecret string
The server AAD application secret.
TenantID string
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
adminGroupObjectIDs string[]
AAD group object IDs that will have admin role of the cluster.
clientAppID string
The client AAD application ID.
enableAzureRBAC boolean
Whether to enable Azure RBAC for Kubernetes authorization.
managed boolean
Whether to enable managed AAD.
serverAppID string
The server AAD application ID.
serverAppSecret string
The server AAD application secret.
tenantID string
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
admin_group_object_ids Sequence[str]
AAD group object IDs that will have admin role of the cluster.
client_app_id str
The client AAD application ID.
enable_azure_rbac bool
Whether to enable Azure RBAC for Kubernetes authorization.
managed bool
Whether to enable managed AAD.
server_app_id str
The server AAD application ID.
server_app_secret str
The server AAD application secret.
tenant_id str
The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.

ManagedClusterAPIServerAccessProfile

AuthorizedIPRanges List<string>
Authorized IP Ranges to kubernetes API server.
EnablePrivateCluster bool
Whether to create the cluster as a private cluster or not.
PrivateDNSZone string
Private dns zone mode for private cluster.
AuthorizedIPRanges []string
Authorized IP Ranges to kubernetes API server.
EnablePrivateCluster bool
Whether to create the cluster as a private cluster or not.
PrivateDNSZone string
Private dns zone mode for private cluster.
authorizedIPRanges string[]
Authorized IP Ranges to kubernetes API server.
enablePrivateCluster boolean
Whether to create the cluster as a private cluster or not.
privateDNSZone string
Private dns zone mode for private cluster.
authorized_ip_ranges Sequence[str]
Authorized IP Ranges to kubernetes API server.
enable_private_cluster bool
Whether to create the cluster as a private cluster or not.
private_dns_zone str
Private dns zone mode for private cluster.

ManagedClusterAPIServerAccessProfileResponse

AuthorizedIPRanges List<string>
Authorized IP Ranges to kubernetes API server.
EnablePrivateCluster bool
Whether to create the cluster as a private cluster or not.
PrivateDNSZone string
Private dns zone mode for private cluster.
AuthorizedIPRanges []string
Authorized IP Ranges to kubernetes API server.
EnablePrivateCluster bool
Whether to create the cluster as a private cluster or not.
PrivateDNSZone string
Private dns zone mode for private cluster.
authorizedIPRanges string[]
Authorized IP Ranges to kubernetes API server.
enablePrivateCluster boolean
Whether to create the cluster as a private cluster or not.
privateDNSZone string
Private dns zone mode for private cluster.
authorized_ip_ranges Sequence[str]
Authorized IP Ranges to kubernetes API server.
enable_private_cluster bool
Whether to create the cluster as a private cluster or not.
private_dns_zone str
Private dns zone mode for private cluster.

ManagedClusterAddonProfile

Enabled bool
Whether the add-on is enabled or not.
Config Dictionary<string, string>
Key-value pairs for configuring an add-on.
Enabled bool
Whether the add-on is enabled or not.
Config map[string]string
Key-value pairs for configuring an add-on.
enabled boolean
Whether the add-on is enabled or not.
config {[key: string]: string}
Key-value pairs for configuring an add-on.
enabled bool
Whether the add-on is enabled or not.
config Mapping[str, str]
Key-value pairs for configuring an add-on.

ManagedClusterAddonProfileResponse

Enabled bool
Whether the add-on is enabled or not.
Identity Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileResponseIdentity
Information of user assigned identity used by this add-on.
Config Dictionary<string, string>
Key-value pairs for configuring an add-on.
Enabled bool
Whether the add-on is enabled or not.
Identity ManagedClusterAddonProfileResponseIdentity
Information of user assigned identity used by this add-on.
Config map[string]string
Key-value pairs for configuring an add-on.
enabled boolean
Whether the add-on is enabled or not.
identity ManagedClusterAddonProfileResponseIdentity
Information of user assigned identity used by this add-on.
config {[key: string]: string}
Key-value pairs for configuring an add-on.
enabled bool
Whether the add-on is enabled or not.
identity ManagedClusterAddonProfileResponseIdentity
Information of user assigned identity used by this add-on.
config Mapping[str, str]
Key-value pairs for configuring an add-on.

ManagedClusterAddonProfileResponseIdentity

ClientId string
The client id of the user assigned identity.
ObjectId string
The object id of the user assigned identity.
ResourceId string
The resource id of the user assigned identity.
ClientId string
The client id of the user assigned identity.
ObjectId string
The object id of the user assigned identity.
ResourceId string
The resource id of the user assigned identity.
clientId string
The client id of the user assigned identity.
objectId string
The object id of the user assigned identity.
resourceId string
The resource id of the user assigned identity.
client_id str
The client id of the user assigned identity.
object_id str
The object id of the user assigned identity.
resource_id str
The resource id of the user assigned identity.

ManagedClusterAgentPoolProfile

Name string
Unique name of the agent pool profile in the context of the subscription and resource group.
AvailabilityZones List<string>
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
Count int
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
EnableAutoScaling bool
Whether to enable auto-scaler
EnableEncryptionAtHost bool
Whether to enable EncryptionAtHost
EnableFIPS bool
Whether to use FIPS enabled OS
EnableNodePublicIP bool
Enable public IP for nodes
GpuInstanceProfile string | Pulumi.AzureNative.ContainerService.GPUInstanceProfile
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
KubeletConfig Pulumi.AzureNative.ContainerService.Inputs.KubeletConfig
KubeletConfig specifies the configuration of kubelet on agent nodes.
KubeletDiskType string | Pulumi.AzureNative.ContainerService.KubeletDiskType
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
LinuxOSConfig Pulumi.AzureNative.ContainerService.Inputs.LinuxOSConfig
LinuxOSConfig specifies the OS configuration of linux agent nodes.
MaxCount int
Maximum number of nodes for auto-scaling
MaxPods int
Maximum number of pods that can run on a node.
MinCount int
Minimum number of nodes for auto-scaling
Mode string | Pulumi.AzureNative.ContainerService.AgentPoolMode
AgentPoolMode represents mode of an agent pool
NodeLabels Dictionary<string, string>
Agent pool node labels to be persisted across all nodes in agent pool.
NodePublicIPPrefixID string
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
NodeTaints List<string>
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
OrchestratorVersion string
Version of orchestrator specified when creating the managed cluster.
OsDiskSizeGB int
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
OsDiskType string | Pulumi.AzureNative.ContainerService.OSDiskType
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
OsSKU string | Pulumi.AzureNative.ContainerService.OSSKU
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
OsType string | Pulumi.AzureNative.ContainerService.OSType
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
PodSubnetID string
Pod SubnetID specifies the VNet’s subnet identifier for pods.
ProximityPlacementGroupID string
The ID for Proximity Placement Group.
ScaleSetEvictionPolicy string | Pulumi.AzureNative.ContainerService.ScaleSetEvictionPolicy
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
ScaleSetPriority string | Pulumi.AzureNative.ContainerService.ScaleSetPriority
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
SpotMaxPrice double
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
Tags Dictionary<string, string>
Agent pool tags to be persisted on the agent pool virtual machine scale set.
Type string | Pulumi.AzureNative.ContainerService.AgentPoolType
AgentPoolType represents types of an agent pool
UpgradeSettings Pulumi.AzureNative.ContainerService.Inputs.AgentPoolUpgradeSettings
Settings for upgrading the agentpool
VmSize string
Size of agent VMs.
VnetSubnetID string
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods
Name string
Unique name of the agent pool profile in the context of the subscription and resource group.
AvailabilityZones []string
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
Count int
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
EnableAutoScaling bool
Whether to enable auto-scaler
EnableEncryptionAtHost bool
Whether to enable EncryptionAtHost
EnableFIPS bool
Whether to use FIPS enabled OS
EnableNodePublicIP bool
Enable public IP for nodes
GpuInstanceProfile string | GPUInstanceProfile
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
KubeletConfig KubeletConfig
KubeletConfig specifies the configuration of kubelet on agent nodes.
KubeletDiskType string | KubeletDiskType
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
LinuxOSConfig LinuxOSConfig
LinuxOSConfig specifies the OS configuration of linux agent nodes.
MaxCount int
Maximum number of nodes for auto-scaling
MaxPods int
Maximum number of pods that can run on a node.
MinCount int
Minimum number of nodes for auto-scaling
Mode string | AgentPoolMode
AgentPoolMode represents mode of an agent pool
NodeLabels map[string]string
Agent pool node labels to be persisted across all nodes in agent pool.
NodePublicIPPrefixID string
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
NodeTaints []string
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
OrchestratorVersion string
Version of orchestrator specified when creating the managed cluster.
OsDiskSizeGB int
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
OsDiskType string | OSDiskType
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
OsSKU string | OSSKU
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
OsType string | OSType
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
PodSubnetID string
Pod SubnetID specifies the VNet’s subnet identifier for pods.
ProximityPlacementGroupID string
The ID for Proximity Placement Group.
ScaleSetEvictionPolicy string | ScaleSetEvictionPolicy
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
ScaleSetPriority string | ScaleSetPriority
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
SpotMaxPrice float64
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
Tags map[string]string
Agent pool tags to be persisted on the agent pool virtual machine scale set.
Type string | AgentPoolType
AgentPoolType represents types of an agent pool
UpgradeSettings AgentPoolUpgradeSettings
Settings for upgrading the agentpool
VmSize string
Size of agent VMs.
VnetSubnetID string
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods
name string
Unique name of the agent pool profile in the context of the subscription and resource group.
availabilityZones string[]
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
count number
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
enableAutoScaling boolean
Whether to enable auto-scaler
enableEncryptionAtHost boolean
Whether to enable EncryptionAtHost
enableFIPS boolean
Whether to use FIPS enabled OS
enableNodePublicIP boolean
Enable public IP for nodes
gpuInstanceProfile string | GPUInstanceProfile
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
kubeletConfig KubeletConfig
KubeletConfig specifies the configuration of kubelet on agent nodes.
kubeletDiskType string | KubeletDiskType
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
linuxOSConfig LinuxOSConfig
LinuxOSConfig specifies the OS configuration of linux agent nodes.
maxCount number
Maximum number of nodes for auto-scaling
maxPods number
Maximum number of pods that can run on a node.
minCount number
Minimum number of nodes for auto-scaling
mode string | AgentPoolMode
AgentPoolMode represents mode of an agent pool
nodeLabels {[key: string]: string}
Agent pool node labels to be persisted across all nodes in agent pool.
nodePublicIPPrefixID string
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
nodeTaints string[]
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
orchestratorVersion string
Version of orchestrator specified when creating the managed cluster.
osDiskSizeGB number
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
osDiskType string | OSDiskType
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
osSKU string | OSSKU
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
osType string | OSType
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
podSubnetID string
Pod SubnetID specifies the VNet’s subnet identifier for pods.
proximityPlacementGroupID string
The ID for Proximity Placement Group.
scaleSetEvictionPolicy string | ScaleSetEvictionPolicy
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
scaleSetPriority string | ScaleSetPriority
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
spotMaxPrice number
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
tags {[key: string]: string}
Agent pool tags to be persisted on the agent pool virtual machine scale set.
type string | AgentPoolType
AgentPoolType represents types of an agent pool
upgradeSettings AgentPoolUpgradeSettings
Settings for upgrading the agentpool
vmSize string
Size of agent VMs.
vnetSubnetID string
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods
name str
Unique name of the agent pool profile in the context of the subscription and resource group.
availability_zones Sequence[str]
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
count int
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
enable_auto_scaling bool
Whether to enable auto-scaler
enable_encryption_at_host bool
Whether to enable EncryptionAtHost
enable_fips bool
Whether to use FIPS enabled OS
enable_node_public_ip bool
Enable public IP for nodes
gpu_instance_profile str | GPUInstanceProfile
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
kubelet_config KubeletConfig
KubeletConfig specifies the configuration of kubelet on agent nodes.
kubelet_disk_type str | KubeletDiskType
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
linux_os_config LinuxOSConfig
LinuxOSConfig specifies the OS configuration of linux agent nodes.
max_count int
Maximum number of nodes for auto-scaling
max_pods int
Maximum number of pods that can run on a node.
min_count int
Minimum number of nodes for auto-scaling
mode str | AgentPoolMode
AgentPoolMode represents mode of an agent pool
node_labels Mapping[str, str]
Agent pool node labels to be persisted across all nodes in agent pool.
node_public_ip_prefix_id str
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
node_taints Sequence[str]
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
orchestrator_version str
Version of orchestrator specified when creating the managed cluster.
os_disk_size_gb int
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
os_disk_type str | OSDiskType
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
os_sku str | OSSKU
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
os_type str | OSType
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
pod_subnet_id str
Pod SubnetID specifies the VNet’s subnet identifier for pods.
proximity_placement_group_id str
The ID for Proximity Placement Group.
scale_set_eviction_policy str | ScaleSetEvictionPolicy
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
scale_set_priority str | ScaleSetPriority
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
spot_max_price float
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
tags Mapping[str, str]
Agent pool tags to be persisted on the agent pool virtual machine scale set.
type str | AgentPoolType
AgentPoolType represents types of an agent pool
upgrade_settings AgentPoolUpgradeSettings
Settings for upgrading the agentpool
vm_size str
Size of agent VMs.
vnet_subnet_id str
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods

ManagedClusterAgentPoolProfileResponse

Name string
Unique name of the agent pool profile in the context of the subscription and resource group.
NodeImageVersion string
Version of node image
PowerState Pulumi.AzureNative.ContainerService.Inputs.PowerStateResponse
Describes whether the Agent Pool is Running or Stopped
ProvisioningState string
The current deployment or provisioning state, which only appears in the response.
AvailabilityZones List<string>
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
Count int
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
EnableAutoScaling bool
Whether to enable auto-scaler
EnableEncryptionAtHost bool
Whether to enable EncryptionAtHost
EnableFIPS bool
Whether to use FIPS enabled OS
EnableNodePublicIP bool
Enable public IP for nodes
GpuInstanceProfile string
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
KubeletConfig Pulumi.AzureNative.ContainerService.Inputs.KubeletConfigResponse
KubeletConfig specifies the configuration of kubelet on agent nodes.
KubeletDiskType string
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
LinuxOSConfig Pulumi.AzureNative.ContainerService.Inputs.LinuxOSConfigResponse
LinuxOSConfig specifies the OS configuration of linux agent nodes.
MaxCount int
Maximum number of nodes for auto-scaling
MaxPods int
Maximum number of pods that can run on a node.
MinCount int
Minimum number of nodes for auto-scaling
Mode string
AgentPoolMode represents mode of an agent pool
NodeLabels Dictionary<string, string>
Agent pool node labels to be persisted across all nodes in agent pool.
NodePublicIPPrefixID string
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
NodeTaints List<string>
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
OrchestratorVersion string
Version of orchestrator specified when creating the managed cluster.
OsDiskSizeGB int
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
OsDiskType string
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
OsSKU string
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
OsType string
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
PodSubnetID string
Pod SubnetID specifies the VNet’s subnet identifier for pods.
ProximityPlacementGroupID string
The ID for Proximity Placement Group.
ScaleSetEvictionPolicy string
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
ScaleSetPriority string
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
SpotMaxPrice double
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
Tags Dictionary<string, string>
Agent pool tags to be persisted on the agent pool virtual machine scale set.
Type string
AgentPoolType represents types of an agent pool
UpgradeSettings Pulumi.AzureNative.ContainerService.Inputs.AgentPoolUpgradeSettingsResponse
Settings for upgrading the agentpool
VmSize string
Size of agent VMs.
VnetSubnetID string
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods
Name string
Unique name of the agent pool profile in the context of the subscription and resource group.
NodeImageVersion string
Version of node image
PowerState PowerStateResponse
Describes whether the Agent Pool is Running or Stopped
ProvisioningState string
The current deployment or provisioning state, which only appears in the response.
AvailabilityZones []string
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
Count int
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
EnableAutoScaling bool
Whether to enable auto-scaler
EnableEncryptionAtHost bool
Whether to enable EncryptionAtHost
EnableFIPS bool
Whether to use FIPS enabled OS
EnableNodePublicIP bool
Enable public IP for nodes
GpuInstanceProfile string
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
KubeletConfig KubeletConfigResponse
KubeletConfig specifies the configuration of kubelet on agent nodes.
KubeletDiskType string
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
LinuxOSConfig LinuxOSConfigResponse
LinuxOSConfig specifies the OS configuration of linux agent nodes.
MaxCount int
Maximum number of nodes for auto-scaling
MaxPods int
Maximum number of pods that can run on a node.
MinCount int
Minimum number of nodes for auto-scaling
Mode string
AgentPoolMode represents mode of an agent pool
NodeLabels map[string]string
Agent pool node labels to be persisted across all nodes in agent pool.
NodePublicIPPrefixID string
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
NodeTaints []string
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
OrchestratorVersion string
Version of orchestrator specified when creating the managed cluster.
OsDiskSizeGB int
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
OsDiskType string
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
OsSKU string
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
OsType string
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
PodSubnetID string
Pod SubnetID specifies the VNet’s subnet identifier for pods.
ProximityPlacementGroupID string
The ID for Proximity Placement Group.
ScaleSetEvictionPolicy string
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
ScaleSetPriority string
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
SpotMaxPrice float64
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
Tags map[string]string
Agent pool tags to be persisted on the agent pool virtual machine scale set.
Type string
AgentPoolType represents types of an agent pool
UpgradeSettings AgentPoolUpgradeSettingsResponse
Settings for upgrading the agentpool
VmSize string
Size of agent VMs.
VnetSubnetID string
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods
name string
Unique name of the agent pool profile in the context of the subscription and resource group.
nodeImageVersion string
Version of node image
powerState PowerStateResponse
Describes whether the Agent Pool is Running or Stopped
provisioningState string
The current deployment or provisioning state, which only appears in the response.
availabilityZones string[]
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
count number
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
enableAutoScaling boolean
Whether to enable auto-scaler
enableEncryptionAtHost boolean
Whether to enable EncryptionAtHost
enableFIPS boolean
Whether to use FIPS enabled OS
enableNodePublicIP boolean
Enable public IP for nodes
gpuInstanceProfile string
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
kubeletConfig KubeletConfigResponse
KubeletConfig specifies the configuration of kubelet on agent nodes.
kubeletDiskType string
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
linuxOSConfig LinuxOSConfigResponse
LinuxOSConfig specifies the OS configuration of linux agent nodes.
maxCount number
Maximum number of nodes for auto-scaling
maxPods number
Maximum number of pods that can run on a node.
minCount number
Minimum number of nodes for auto-scaling
mode string
AgentPoolMode represents mode of an agent pool
nodeLabels {[key: string]: string}
Agent pool node labels to be persisted across all nodes in agent pool.
nodePublicIPPrefixID string
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
nodeTaints string[]
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
orchestratorVersion string
Version of orchestrator specified when creating the managed cluster.
osDiskSizeGB number
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
osDiskType string
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
osSKU string
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
osType string
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
podSubnetID string
Pod SubnetID specifies the VNet’s subnet identifier for pods.
proximityPlacementGroupID string
The ID for Proximity Placement Group.
scaleSetEvictionPolicy string
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
scaleSetPriority string
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
spotMaxPrice number
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
tags {[key: string]: string}
Agent pool tags to be persisted on the agent pool virtual machine scale set.
type string
AgentPoolType represents types of an agent pool
upgradeSettings AgentPoolUpgradeSettingsResponse
Settings for upgrading the agentpool
vmSize string
Size of agent VMs.
vnetSubnetID string
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods
name str
Unique name of the agent pool profile in the context of the subscription and resource group.
node_image_version str
Version of node image
power_state PowerStateResponse
Describes whether the Agent Pool is Running or Stopped
provisioning_state str
The current deployment or provisioning state, which only appears in the response.
availability_zones Sequence[str]
Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.
count int
Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.
enable_auto_scaling bool
Whether to enable auto-scaler
enable_encryption_at_host bool
Whether to enable EncryptionAtHost
enable_fips bool
Whether to use FIPS enabled OS
enable_node_public_ip bool
Enable public IP for nodes
gpu_instance_profile str
GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.
kubelet_config KubeletConfigResponse
KubeletConfig specifies the configuration of kubelet on agent nodes.
kubelet_disk_type str
KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.
linux_os_config LinuxOSConfigResponse
LinuxOSConfig specifies the OS configuration of linux agent nodes.
max_count int
Maximum number of nodes for auto-scaling
max_pods int
Maximum number of pods that can run on a node.
min_count int
Minimum number of nodes for auto-scaling
mode str
AgentPoolMode represents mode of an agent pool
node_labels Mapping[str, str]
Agent pool node labels to be persisted across all nodes in agent pool.
node_public_ip_prefix_id str
Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.
node_taints Sequence[str]
Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
orchestrator_version str
Version of orchestrator specified when creating the managed cluster.
os_disk_size_gb int
OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.
os_disk_type str
OS disk type to be used for machines in a given agent pool. Allowed values are ‘Ephemeral’ and ‘Managed’. If unspecified, defaults to ‘Ephemeral’ when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to ‘Managed’. May not be changed after creation.
os_sku str
OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.
os_type str
OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.
pod_subnet_id str
Pod SubnetID specifies the VNet’s subnet identifier for pods.
proximity_placement_group_id str
The ID for Proximity Placement Group.
scale_set_eviction_policy str
ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.
scale_set_priority str
ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.
spot_max_price float
SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.
tags Mapping[str, str]
Agent pool tags to be persisted on the agent pool virtual machine scale set.
type str
AgentPoolType represents types of an agent pool
upgrade_settings AgentPoolUpgradeSettingsResponse
Settings for upgrading the agentpool
vm_size str
Size of agent VMs.
vnet_subnet_id str
VNet SubnetID specifies the VNet’s subnet identifier for nodes and maybe pods

ManagedClusterAutoUpgradeProfile

UpgradeChannel string | Pulumi.AzureNative.ContainerService.UpgradeChannel
upgrade channel for auto upgrade.
UpgradeChannel string | UpgradeChannel
upgrade channel for auto upgrade.
upgradeChannel string | UpgradeChannel
upgrade channel for auto upgrade.
upgrade_channel str | UpgradeChannel
upgrade channel for auto upgrade.

ManagedClusterAutoUpgradeProfileResponse

UpgradeChannel string
upgrade channel for auto upgrade.
UpgradeChannel string
upgrade channel for auto upgrade.
upgradeChannel string
upgrade channel for auto upgrade.
upgrade_channel str
upgrade channel for auto upgrade.

ManagedClusterHTTPProxyConfig

HttpProxy string
HTTP proxy server endpoint to use.
HttpsProxy string
HTTPS proxy server endpoint to use.
NoProxy List<string>
Endpoints that should not go through proxy.
TrustedCa string
Alternative CA cert to use for connecting to proxy servers.
HttpProxy string
HTTP proxy server endpoint to use.
HttpsProxy string
HTTPS proxy server endpoint to use.
NoProxy []string
Endpoints that should not go through proxy.
TrustedCa string
Alternative CA cert to use for connecting to proxy servers.
httpProxy string
HTTP proxy server endpoint to use.
httpsProxy string
HTTPS proxy server endpoint to use.
noProxy string[]
Endpoints that should not go through proxy.
trustedCa string
Alternative CA cert to use for connecting to proxy servers.
http_proxy str
HTTP proxy server endpoint to use.
https_proxy str
HTTPS proxy server endpoint to use.
no_proxy Sequence[str]
Endpoints that should not go through proxy.
trusted_ca str
Alternative CA cert to use for connecting to proxy servers.

ManagedClusterHTTPProxyConfigResponse

HttpProxy string
HTTP proxy server endpoint to use.
HttpsProxy string
HTTPS proxy server endpoint to use.
NoProxy List<string>
Endpoints that should not go through proxy.
TrustedCa string
Alternative CA cert to use for connecting to proxy servers.
HttpProxy string
HTTP proxy server endpoint to use.
HttpsProxy string
HTTPS proxy server endpoint to use.
NoProxy []string
Endpoints that should not go through proxy.
TrustedCa string
Alternative CA cert to use for connecting to proxy servers.
httpProxy string
HTTP proxy server endpoint to use.
httpsProxy string
HTTPS proxy server endpoint to use.
noProxy string[]
Endpoints that should not go through proxy.
trustedCa string
Alternative CA cert to use for connecting to proxy servers.
http_proxy str
HTTP proxy server endpoint to use.
https_proxy str
HTTPS proxy server endpoint to use.
no_proxy Sequence[str]
Endpoints that should not go through proxy.
trusted_ca str
Alternative CA cert to use for connecting to proxy servers.

ManagedClusterIdentity

Type Pulumi.AzureNative.ContainerService.ResourceIdentityType
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
UserAssignedIdentities Dictionary<string, object>
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.
Type ResourceIdentityType
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
UserAssignedIdentities map[string]interface{}
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.
type ResourceIdentityType
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
userAssignedIdentities {[key: string]: any}
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.
type ResourceIdentityType
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
user_assigned_identities Mapping[str, Any]
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.

ManagedClusterIdentityResponse

PrincipalId string
The principal id of the system assigned identity which is used by master components.
TenantId string
The tenant id of the system assigned identity which is used by master components.
Type string
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
UserAssignedIdentities Dictionary<string, Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterIdentityResponseUserAssignedIdentities>
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.
PrincipalId string
The principal id of the system assigned identity which is used by master components.
TenantId string
The tenant id of the system assigned identity which is used by master components.
Type string
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
UserAssignedIdentities map[string]ManagedClusterIdentityResponseUserAssignedIdentities
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.
principalId string
The principal id of the system assigned identity which is used by master components.
tenantId string
The tenant id of the system assigned identity which is used by master components.
type string
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
userAssignedIdentities {[key: string]: ManagedClusterIdentityResponseUserAssignedIdentities}
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.
principal_id str
The principal id of the system assigned identity which is used by master components.
tenant_id str
The tenant id of the system assigned identity which is used by master components.
type str
The type of identity used for the managed cluster. Type ‘SystemAssigned’ will use an implicitly created identity in master components and an auto-created user assigned identity in MC_ resource group in agent nodes. Type ‘None’ will not use MSI for the managed cluster, service principal will be used instead.
user_assigned_identities Mapping[str, ManagedClusterIdentityResponseUserAssignedIdentities]
The user identity associated with the managed cluster. This identity will be used in control plane and only one user assigned identity is allowed. The user identity dictionary key references will be ARM resource ids in the form: ‘/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}’.

ManagedClusterIdentityResponseUserAssignedIdentities

ClientId string
The client id of user assigned identity.
PrincipalId string
The principal id of user assigned identity.
ClientId string
The client id of user assigned identity.
PrincipalId string
The principal id of user assigned identity.
clientId string
The client id of user assigned identity.
principalId string
The principal id of user assigned identity.
client_id str
The client id of user assigned identity.
principal_id str
The principal id of user assigned identity.

ManagedClusterLoadBalancerProfile

AllocatedOutboundPorts int
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
EffectiveOutboundIPs List<Pulumi.AzureNative.ContainerService.Inputs.ResourceReference>
The effective outbound IP resources of the cluster load balancer.
IdleTimeoutInMinutes int
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
ManagedOutboundIPs Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
OutboundIPPrefixes Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
OutboundIPs Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileOutboundIPs
Desired outbound IP resources for the cluster load balancer.
AllocatedOutboundPorts int
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
EffectiveOutboundIPs []ResourceReference
The effective outbound IP resources of the cluster load balancer.
IdleTimeoutInMinutes int
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
ManagedOutboundIPs ManagedClusterLoadBalancerProfileManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
OutboundIPPrefixes ManagedClusterLoadBalancerProfileOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
OutboundIPs ManagedClusterLoadBalancerProfileOutboundIPs
Desired outbound IP resources for the cluster load balancer.
allocatedOutboundPorts number
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
effectiveOutboundIPs ResourceReference[]
The effective outbound IP resources of the cluster load balancer.
idleTimeoutInMinutes number
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
managedOutboundIPs ManagedClusterLoadBalancerProfileManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
outboundIPPrefixes ManagedClusterLoadBalancerProfileOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
outboundIPs ManagedClusterLoadBalancerProfileOutboundIPs
Desired outbound IP resources for the cluster load balancer.
allocated_outbound_ports int
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
effective_outbound_ips Sequence[ResourceReference]
The effective outbound IP resources of the cluster load balancer.
idle_timeout_in_minutes int
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
managed_outbound_ips ManagedClusterLoadBalancerProfileManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
outbound_ip_prefixes ManagedClusterLoadBalancerProfileOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
outbound_ips ManagedClusterLoadBalancerProfileOutboundIPs
Desired outbound IP resources for the cluster load balancer.

ManagedClusterLoadBalancerProfileManagedOutboundIPs

Count int
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.
Count int
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.
count number
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.
count int
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.

ManagedClusterLoadBalancerProfileOutboundIPPrefixes

PublicIPPrefixes List<Pulumi.AzureNative.ContainerService.Inputs.ResourceReference>
A list of public IP prefix resources.
PublicIPPrefixes []ResourceReference
A list of public IP prefix resources.
publicIPPrefixes ResourceReference[]
A list of public IP prefix resources.
public_ip_prefixes Sequence[ResourceReference]
A list of public IP prefix resources.

ManagedClusterLoadBalancerProfileOutboundIPs

PublicIPs List<Pulumi.AzureNative.ContainerService.Inputs.ResourceReference>
A list of public IP resources.
PublicIPs []ResourceReference
A list of public IP resources.
publicIPs ResourceReference[]
A list of public IP resources.
public_ips Sequence[ResourceReference]
A list of public IP resources.

ManagedClusterLoadBalancerProfileResponse

AllocatedOutboundPorts int
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
EffectiveOutboundIPs List<Pulumi.AzureNative.ContainerService.Inputs.ResourceReferenceResponse>
The effective outbound IP resources of the cluster load balancer.
IdleTimeoutInMinutes int
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
ManagedOutboundIPs Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileResponseManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
OutboundIPPrefixes Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileResponseOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
OutboundIPs Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileResponseOutboundIPs
Desired outbound IP resources for the cluster load balancer.
AllocatedOutboundPorts int
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
EffectiveOutboundIPs []ResourceReferenceResponse
The effective outbound IP resources of the cluster load balancer.
IdleTimeoutInMinutes int
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
ManagedOutboundIPs ManagedClusterLoadBalancerProfileResponseManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
OutboundIPPrefixes ManagedClusterLoadBalancerProfileResponseOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
OutboundIPs ManagedClusterLoadBalancerProfileResponseOutboundIPs
Desired outbound IP resources for the cluster load balancer.
allocatedOutboundPorts number
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
effectiveOutboundIPs ResourceReferenceResponse[]
The effective outbound IP resources of the cluster load balancer.
idleTimeoutInMinutes number
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
managedOutboundIPs ManagedClusterLoadBalancerProfileResponseManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
outboundIPPrefixes ManagedClusterLoadBalancerProfileResponseOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
outboundIPs ManagedClusterLoadBalancerProfileResponseOutboundIPs
Desired outbound IP resources for the cluster load balancer.
allocated_outbound_ports int
Desired number of allocated SNAT ports per VM. Allowed values must be in the range of 0 to 64000 (inclusive). The default value is 0 which results in Azure dynamically allocating ports.
effective_outbound_ips Sequence[ResourceReferenceResponse]
The effective outbound IP resources of the cluster load balancer.
idle_timeout_in_minutes int
Desired outbound flow idle timeout in minutes. Allowed values must be in the range of 4 to 120 (inclusive). The default value is 30 minutes.
managed_outbound_ips ManagedClusterLoadBalancerProfileResponseManagedOutboundIPs
Desired managed outbound IPs for the cluster load balancer.
outbound_ip_prefixes ManagedClusterLoadBalancerProfileResponseOutboundIPPrefixes
Desired outbound IP Prefix resources for the cluster load balancer.
outbound_ips ManagedClusterLoadBalancerProfileResponseOutboundIPs
Desired outbound IP resources for the cluster load balancer.

ManagedClusterLoadBalancerProfileResponseManagedOutboundIPs

Count int
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.
Count int
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.
count number
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.
count int
Desired number of outbound IP created/managed by Azure for the cluster load balancer. Allowed values must be in the range of 1 to 100 (inclusive). The default value is 1.

ManagedClusterLoadBalancerProfileResponseOutboundIPPrefixes

PublicIPPrefixes List<Pulumi.AzureNative.ContainerService.Inputs.ResourceReferenceResponse>
A list of public IP prefix resources.
PublicIPPrefixes []ResourceReferenceResponse
A list of public IP prefix resources.
publicIPPrefixes ResourceReferenceResponse[]
A list of public IP prefix resources.
public_ip_prefixes Sequence[ResourceReferenceResponse]
A list of public IP prefix resources.

ManagedClusterLoadBalancerProfileResponseOutboundIPs

PublicIPs List<Pulumi.AzureNative.ContainerService.Inputs.ResourceReferenceResponse>
A list of public IP resources.
PublicIPs []ResourceReferenceResponse
A list of public IP resources.
publicIPs ResourceReferenceResponse[]
A list of public IP resources.
public_ips Sequence[ResourceReferenceResponse]
A list of public IP resources.

ManagedClusterPodIdentity

Identity Pulumi.AzureNative.ContainerService.Inputs.UserAssignedIdentity
Information of the user assigned identity.
Name string
Name of the pod identity.
Namespace string
Namespace of the pod identity.
BindingSelector string
Binding selector to use for the AzureIdentityBinding resource.
Identity UserAssignedIdentity
Information of the user assigned identity.
Name string
Name of the pod identity.
Namespace string
Namespace of the pod identity.
BindingSelector string
Binding selector to use for the AzureIdentityBinding resource.
identity UserAssignedIdentity
Information of the user assigned identity.
name string
Name of the pod identity.
namespace string
Namespace of the pod identity.
bindingSelector string
Binding selector to use for the AzureIdentityBinding resource.
identity UserAssignedIdentity
Information of the user assigned identity.
name str
Name of the pod identity.
namespace str
Namespace of the pod identity.
binding_selector str
Binding selector to use for the AzureIdentityBinding resource.

ManagedClusterPodIdentityException

Name string
Name of the pod identity exception.
Namespace string
Namespace of the pod identity exception.
PodLabels Dictionary<string, string>
Pod labels to match.
Name string
Name of the pod identity exception.
Namespace string
Namespace of the pod identity exception.
PodLabels map[string]string
Pod labels to match.
name string
Name of the pod identity exception.
namespace string
Namespace of the pod identity exception.
podLabels {[key: string]: string}
Pod labels to match.
name str
Name of the pod identity exception.
namespace str
Namespace of the pod identity exception.
pod_labels Mapping[str, str]
Pod labels to match.

ManagedClusterPodIdentityExceptionResponse

Name string
Name of the pod identity exception.
Namespace string
Namespace of the pod identity exception.
PodLabels Dictionary<string, string>
Pod labels to match.
Name string
Name of the pod identity exception.
Namespace string
Namespace of the pod identity exception.
PodLabels map[string]string
Pod labels to match.
name string
Name of the pod identity exception.
namespace string
Namespace of the pod identity exception.
podLabels {[key: string]: string}
Pod labels to match.
name str
Name of the pod identity exception.
namespace str
Namespace of the pod identity exception.
pod_labels Mapping[str, str]
Pod labels to match.

ManagedClusterPodIdentityProfile

AllowNetworkPluginKubenet bool
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
Enabled bool
Whether the pod identity addon is enabled.
UserAssignedIdentities List<Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPodIdentity>
User assigned pod identity settings.
UserAssignedIdentityExceptions List<Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityException>
User assigned pod identity exception settings.
AllowNetworkPluginKubenet bool
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
Enabled bool
Whether the pod identity addon is enabled.
UserAssignedIdentities []ManagedClusterPodIdentity
User assigned pod identity settings.
UserAssignedIdentityExceptions []ManagedClusterPodIdentityException
User assigned pod identity exception settings.
allowNetworkPluginKubenet boolean
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
enabled boolean
Whether the pod identity addon is enabled.
userAssignedIdentities ManagedClusterPodIdentity[]
User assigned pod identity settings.
userAssignedIdentityExceptions ManagedClusterPodIdentityException[]
User assigned pod identity exception settings.
allow_network_plugin_kubenet bool
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
enabled bool
Whether the pod identity addon is enabled.
user_assigned_identities Sequence[ManagedClusterPodIdentity]
User assigned pod identity settings.
user_assigned_identity_exceptions Sequence[ManagedClusterPodIdentityException]
User assigned pod identity exception settings.

ManagedClusterPodIdentityProfileResponse

AllowNetworkPluginKubenet bool
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
Enabled bool
Whether the pod identity addon is enabled.
UserAssignedIdentities List<Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityResponse>
User assigned pod identity settings.
UserAssignedIdentityExceptions List<Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityExceptionResponse>
User assigned pod identity exception settings.
AllowNetworkPluginKubenet bool
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
Enabled bool
Whether the pod identity addon is enabled.
UserAssignedIdentities []ManagedClusterPodIdentityResponse
User assigned pod identity settings.
UserAssignedIdentityExceptions []ManagedClusterPodIdentityExceptionResponse
User assigned pod identity exception settings.
allowNetworkPluginKubenet boolean
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
enabled boolean
Whether the pod identity addon is enabled.
userAssignedIdentities ManagedClusterPodIdentityResponse[]
User assigned pod identity settings.
userAssignedIdentityExceptions ManagedClusterPodIdentityExceptionResponse[]
User assigned pod identity exception settings.
allow_network_plugin_kubenet bool
Customer consent for enabling AAD pod identity addon in cluster using Kubenet network plugin.
enabled bool
Whether the pod identity addon is enabled.
user_assigned_identities Sequence[ManagedClusterPodIdentityResponse]
User assigned pod identity settings.
user_assigned_identity_exceptions Sequence[ManagedClusterPodIdentityExceptionResponse]
User assigned pod identity exception settings.

ManagedClusterPodIdentityResponse

Identity Pulumi.AzureNative.ContainerService.Inputs.UserAssignedIdentityResponse
Information of the user assigned identity.
Name string
Name of the pod identity.
Namespace string
Namespace of the pod identity.
ProvisioningInfo Pulumi.AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityResponseProvisioningInfo
ProvisioningState string
The current provisioning state of the pod identity.
BindingSelector string
Binding selector to use for the AzureIdentityBinding resource.
Identity UserAssignedIdentityResponse
Information of the user assigned identity.
Name string
Name of the pod identity.
Namespace string
Namespace of the pod identity.
ProvisioningInfo ManagedClusterPodIdentityResponseProvisioningInfo
ProvisioningState string
The current provisioning state of the pod identity.
BindingSelector string
Binding selector to use for the AzureIdentityBinding resource.
identity UserAssignedIdentityResponse
Information of the user assigned identity.
name string
Name of the pod identity.
namespace string
Namespace of the pod identity.
provisioningInfo ManagedClusterPodIdentityResponseProvisioningInfo
provisioningState string
The current provisioning state of the pod identity.
bindingSelector string
Binding selector to use for the AzureIdentityBinding resource.
identity UserAssignedIdentityResponse
Information of the user assigned identity.
name str
Name of the pod identity.
namespace str
Namespace of the pod identity.
provisioning_info ManagedClusterPodIdentityResponseProvisioningInfo
provisioning_state str
The current provisioning state of the pod identity.
binding_selector str
Binding selector to use for the AzureIdentityBinding resource.

ManagedClusterPodIdentityResponseProvisioningInfo

Error Pulumi.AzureNative.ContainerService.Inputs.CloudErrorResponse
Pod identity assignment error (if any).
Error CloudErrorResponse
Pod identity assignment error (if any).
error CloudErrorResponse
Pod identity assignment error (if any).
error CloudErrorResponse
Pod identity assignment error (if any).

ManagedClusterPropertiesAutoScalerProfile

BalanceSimilarNodeGroups string
Expander string | Pulumi.AzureNative.ContainerService.Expander
MaxEmptyBulkDelete string
MaxGracefulTerminationSec string
MaxNodeProvisionTime string
MaxTotalUnreadyPercentage string
NewPodScaleUpDelay string
OkTotalUnreadyCount string
ScaleDownDelayAfterAdd string
ScaleDownDelayAfterDelete string
ScaleDownDelayAfterFailure string
ScaleDownUnneededTime string
ScaleDownUnreadyTime string
ScaleDownUtilizationThreshold string
ScanInterval string
SkipNodesWithLocalStorage string
SkipNodesWithSystemPods string
BalanceSimilarNodeGroups string
Expander string | Expander
MaxEmptyBulkDelete string
MaxGracefulTerminationSec string
MaxNodeProvisionTime string
MaxTotalUnreadyPercentage string
NewPodScaleUpDelay string
OkTotalUnreadyCount string
ScaleDownDelayAfterAdd string
ScaleDownDelayAfterDelete string
ScaleDownDelayAfterFailure string
ScaleDownUnneededTime string
ScaleDownUnreadyTime string
ScaleDownUtilizationThreshold string
ScanInterval string
SkipNodesWithLocalStorage string
SkipNodesWithSystemPods string
balanceSimilarNodeGroups string
expander string | Expander
maxEmptyBulkDelete string
maxGracefulTerminationSec string
maxNodeProvisionTime string
maxTotalUnreadyPercentage string
newPodScaleUpDelay string
okTotalUnreadyCount string
scaleDownDelayAfterAdd string
scaleDownDelayAfterDelete string
scaleDownDelayAfterFailure string
scaleDownUnneededTime string
scaleDownUnreadyTime string
scaleDownUtilizationThreshold string
scanInterval string
skipNodesWithLocalStorage string
skipNodesWithSystemPods string
balance_similar_node_groups str
expander str | Expander
max_empty_bulk_delete str
max_graceful_termination_sec str
max_node_provision_time str
max_total_unready_percentage str
new_pod_scale_up_delay str
ok_total_unready_count str
scale_down_delay_after_add str
scale_down_delay_after_delete str
scale_down_delay_after_failure str
scale_down_unneeded_time str
scale_down_unready_time str
scale_down_utilization_threshold str
scan_interval str
skip_nodes_with_local_storage str
skip_nodes_with_system_pods str

ManagedClusterPropertiesIdentityProfile

ClientId string
The client id of the user assigned identity.
ObjectId string
The object id of the user assigned identity.
ResourceId string
The resource id of the user assigned identity.
ClientId string
The client id of the user assigned identity.
ObjectId string
The object id of the user assigned identity.
ResourceId string
The resource id of the user assigned identity.
clientId string
The client id of the user assigned identity.
objectId string
The object id of the user assigned identity.
resourceId string
The resource id of the user assigned identity.
client_id str
The client id of the user assigned identity.
object_id str
The object id of the user assigned identity.
resource_id str
The resource id of the user assigned identity.

ManagedClusterPropertiesResponseAutoScalerProfile

BalanceSimilarNodeGroups string
Expander string
MaxEmptyBulkDelete string
MaxGracefulTerminationSec string
MaxNodeProvisionTime string
MaxTotalUnreadyPercentage string
NewPodScaleUpDelay string
OkTotalUnreadyCount string
ScaleDownDelayAfterAdd string
ScaleDownDelayAfterDelete string
ScaleDownDelayAfterFailure string
ScaleDownUnneededTime string
ScaleDownUnreadyTime string
ScaleDownUtilizationThreshold string
ScanInterval string
SkipNodesWithLocalStorage string
SkipNodesWithSystemPods string
BalanceSimilarNodeGroups string
Expander string
MaxEmptyBulkDelete string
MaxGracefulTerminationSec string
MaxNodeProvisionTime string
MaxTotalUnreadyPercentage string
NewPodScaleUpDelay string
OkTotalUnreadyCount string
ScaleDownDelayAfterAdd string
ScaleDownDelayAfterDelete string
ScaleDownDelayAfterFailure string
ScaleDownUnneededTime string
ScaleDownUnreadyTime string
ScaleDownUtilizationThreshold string
ScanInterval string
SkipNodesWithLocalStorage string
SkipNodesWithSystemPods string
balanceSimilarNodeGroups string
expander string
maxEmptyBulkDelete string
maxGracefulTerminationSec string
maxNodeProvisionTime string
maxTotalUnreadyPercentage string
newPodScaleUpDelay string
okTotalUnreadyCount string
scaleDownDelayAfterAdd string
scaleDownDelayAfterDelete string
scaleDownDelayAfterFailure string
scaleDownUnneededTime string
scaleDownUnreadyTime string
scaleDownUtilizationThreshold string
scanInterval string
skipNodesWithLocalStorage string
skipNodesWithSystemPods string
balance_similar_node_groups str
expander str
max_empty_bulk_delete str
max_graceful_termination_sec str
max_node_provision_time str
max_total_unready_percentage str
new_pod_scale_up_delay str
ok_total_unready_count str
scale_down_delay_after_add str
scale_down_delay_after_delete str
scale_down_delay_after_failure str
scale_down_unneeded_time str
scale_down_unready_time str
scale_down_utilization_threshold str
scan_interval str
skip_nodes_with_local_storage str
skip_nodes_with_system_pods str

ManagedClusterPropertiesResponseIdentityProfile

ClientId string
The client id of the user assigned identity.
ObjectId string
The object id of the user assigned identity.
ResourceId string
The resource id of the user assigned identity.
ClientId string
The client id of the user assigned identity.
ObjectId string
The object id of the user assigned identity.
ResourceId string
The resource id of the user assigned identity.
clientId string
The client id of the user assigned identity.
objectId string
The object id of the user assigned identity.
resourceId string
The resource id of the user assigned identity.
client_id str
The client id of the user assigned identity.
object_id str
The object id of the user assigned identity.
resource_id str
The resource id of the user assigned identity.

ManagedClusterSKU

Name string | Pulumi.AzureNative.ContainerService.ManagedClusterSKUName
Name of a managed cluster SKU.
Tier string | Pulumi.AzureNative.ContainerService.ManagedClusterSKUTier
Tier of a managed cluster SKU.
Name string | ManagedClusterSKUName
Name of a managed cluster SKU.
Tier string | ManagedClusterSKUTier
Tier of a managed cluster SKU.
name string | ManagedClusterSKUName
Name of a managed cluster SKU.
tier string | ManagedClusterSKUTier
Tier of a managed cluster SKU.
name str | ManagedClusterSKUName
Name of a managed cluster SKU.
tier str | ManagedClusterSKUTier
Tier of a managed cluster SKU.

ManagedClusterSKUName

Basic
Basic
ManagedClusterSKUNameBasic
Basic
Basic
Basic
BASIC
Basic

ManagedClusterSKUResponse

Name string
Name of a managed cluster SKU.
Tier string
Tier of a managed cluster SKU.
Name string
Name of a managed cluster SKU.
Tier string
Tier of a managed cluster SKU.
name string
Name of a managed cluster SKU.
tier string
Tier of a managed cluster SKU.
name str
Name of a managed cluster SKU.
tier str
Tier of a managed cluster SKU.

ManagedClusterSKUTier

Paid
Paid
Free
Free
ManagedClusterSKUTierPaid
Paid
ManagedClusterSKUTierFree
Free
Paid
Paid
Free
Free
PAID
Paid
FREE
Free

ManagedClusterServicePrincipalProfile

ClientId string
The ID for the service principal.
Secret string
The secret password associated with the service principal in plain text.
ClientId string
The ID for the service principal.
Secret string
The secret password associated with the service principal in plain text.
clientId string
The ID for the service principal.
secret string
The secret password associated with the service principal in plain text.
client_id str
The ID for the service principal.
secret str
The secret password associated with the service principal in plain text.

ManagedClusterServicePrincipalProfileResponse

ClientId string
The ID for the service principal.
Secret string
The secret password associated with the service principal in plain text.
ClientId string
The ID for the service principal.
Secret string
The secret password associated with the service principal in plain text.
clientId string
The ID for the service principal.
secret string
The secret password associated with the service principal in plain text.
client_id str
The ID for the service principal.
secret str
The secret password associated with the service principal in plain text.

ManagedClusterWindowsProfile

AdminUsername string
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
AdminPassword string
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
EnableCSIProxy bool
Whether to enable CSI proxy.
LicenseType string | Pulumi.AzureNative.ContainerService.LicenseType
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.
AdminUsername string
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
AdminPassword string
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
EnableCSIProxy bool
Whether to enable CSI proxy.
LicenseType string | LicenseType
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.
adminUsername string
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
adminPassword string
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
enableCSIProxy boolean
Whether to enable CSI proxy.
licenseType string | LicenseType
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.
admin_username str
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
admin_password str
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
enable_csi_proxy bool
Whether to enable CSI proxy.
license_type str | LicenseType
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.

ManagedClusterWindowsProfileResponse

AdminUsername string
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
AdminPassword string
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
EnableCSIProxy bool
Whether to enable CSI proxy.
LicenseType string
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.
AdminUsername string
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
AdminPassword string
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
EnableCSIProxy bool
Whether to enable CSI proxy.
LicenseType string
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.
adminUsername string
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “console”, “david”, “guest”, “john”, “owner”, “root”, “server”, “sql”, “support”, “support_388945a0”, “sys”, “test2”, “test3”, “user4”, “user5”.

Minimum-length: 1 character

Max-length: 20 characters
adminPassword string
Specifies the password of the administrator account.

Minimum-length: 8 characters

Max-length: 123 characters

Complexity requirements: 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])

**Disallowed values:** “abc@123”, “P@$$w0rd”, “P@ssw0rd”, “P@ssword123”, “Pa$$word”, “pass@word1”, “Password!”, “Password1”, “Password22”, “iloveyou!”
enableCSIProxy boolean
Whether to enable CSI proxy.
licenseType string
The licenseType to use for Windows VMs. Windows_Server is used to enable Azure Hybrid User Benefits for Windows VMs.
admin_username str
Specifies the name of the administrator account.

restriction: Cannot end in “.”

Disallowed values: “administrator”, “admin”, “user”, “user1”, “test”, “user2”, “test1”, “user3”, “admin1”, “1”, “123”, “a”, “actuser”, “adm”, “admin2”, “aspnet”, “backup”, “con