Azure Native v2.76.0, Dec 6 24

This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.

Azure Native v2.76.0 published on Friday, Dec 6, 2024 by Pulumi

pulumi/pulumi-azure-native

azure-native.containerservice.ManagedCluster

Explore with Pulumi AI

This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.

Azure Native v2.76.0 published on Friday, Dec 6, 2024 by Pulumi

pulumi/pulumi-azure-native

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

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

Example Usage

Create Managed Cluster using an agent pool snapshot

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                CreationData = new AzureNative.ContainerService.Inputs.CreationDataArgs
                {
                    SourceResourceId = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
                },
                EnableFIPS = true,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = false,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.CreationDataArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .creationData(CreationDataArgs.builder()
                    .sourceResourceId("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1")
                    .build())
                .enableFIPS(true)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(false)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "creation_data": {
            "source_resource_id": "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
        },
        "enable_fips": True,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

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

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = false,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            NatGatewayProfile = new AzureNative.ContainerService.Inputs.ManagedClusterNATGatewayProfileArgs
            {
                ManagedOutboundIPProfile = new AzureNative.ContainerService.Inputs.ManagedClusterManagedOutboundIPProfileArgs
                {
                    Count = 2,
                },
            },
            OutboundType = AzureNative.ContainerService.OutboundType.ManagedNATGateway,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: containerservice.ManagedClusterAddonProfileMap{},
			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:              pulumi.Int(3),
					EnableNodePublicIP: pulumi.Bool(false),
					Mode:               pulumi.String(containerservice.AgentPoolModeSystem),
					Name:               pulumi.String("nodepool1"),
					OsType:             pulumi.String(containerservice.OSTypeLinux),
					Type:               pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
					VmSize:             pulumi.String("Standard_DS2_v2"),
				},
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DiskEncryptionSetID:     pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
				NatGatewayProfile: &containerservice.ManagedClusterNATGatewayProfileArgs{
					ManagedOutboundIPProfile: &containerservice.ManagedClusterManagedOutboundIPProfileArgs{
						Count: pulumi.Int(2),
					},
				},
				OutboundType: pulumi.String(containerservice.OutboundTypeManagedNATGateway),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String("Basic"),
				Tier: pulumi.String(containerservice.ManagedClusterSKUTierFree),
			},
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String("replacePassword1234$"),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterNATGatewayProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterManagedOutboundIPProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(false)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerSku("standard")
                .natGatewayProfile(ManagedClusterNATGatewayProfileArgs.builder()
                    .managedOutboundIPProfile(ManagedClusterManagedOutboundIPProfileArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .outboundType("managedNATGateway")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": False,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "nat_gateway_profile": {
            "managed_outbound_ip_profile": {
                "count": 2,
            },
        },
        "outbound_type": azure_native.containerservice.OutboundType.MANAGED_NAT_GATEWAY,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

resources:
  managedCluster:
    type: azure-native:containerservice:ManagedCluster
    properties:
      addonProfiles: {}
      agentPoolProfiles:
        - count: 3
          enableNodePublicIP: false
          mode: System
          name: nodepool1
          osType: Linux
          type: VirtualMachineScaleSets
          vmSize: Standard_DS2_v2
      autoScalerProfile:
        scaleDownDelayAfterAdd: 15m
        scanInterval: 20s
      diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
      dnsPrefix: dnsprefix1
      enablePodSecurityPolicy: true
      enableRBAC: true
      kubernetesVersion: ""
      linuxProfile:
        adminUsername: azureuser
        ssh:
          publicKeys:
            - keyData: keydata
      location: location1
      networkProfile:
        loadBalancerSku: standard
        natGatewayProfile:
          managedOutboundIPProfile:
            count: 2
        outboundType: managedNATGateway
      resourceGroupName: rg1
      resourceName: clustername1
      servicePrincipalProfile:
        clientId: clientid
        secret: secret
      sku:
        name: Basic
        tier: Free
      tags:
        archv2: ""
        tier: production
      windowsProfile:
        adminPassword: replacePassword1234$
        adminUsername: azureuser

Create Managed Cluster with Azure KeyVault Secrets Provider Addon

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = 
        {
            { "azureKeyvaultSecretsProvider", new AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileArgs
            {
                Config = 
                {
                    { "enableSecretRotation", "true" },
                    { "rotationPollInterval", "2m" },
                },
                Enabled = true,
            } },
        },
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles(Map.of("azureKeyvaultSecretsProvider", Map.ofEntries(
                Map.entry("config", Map.ofEntries(
                    Map.entry("enableSecretRotation", "true"),
                    Map.entry("rotationPollInterval", "2m")
                )),
                Map.entry("enabled", true)
            )))
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={
        "azureKeyvaultSecretsProvider": {
            "config": {
                "enableSecretRotation": "true",
                "rotationPollInterval": "2m",
            },
            "enabled": True,
        },
    },
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with Dedicated Host Group

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                HostGroupID = "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = false,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .hostGroupID("/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(false)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "host_group_id": "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

resources:
  managedCluster:
    type: azure-native:containerservice:ManagedCluster
    properties:
      addonProfiles: {}
      agentPoolProfiles:
        - count: 3
          enableNodePublicIP: true
          hostGroupID: /subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1
          name: nodepool1
          osType: Linux
          type: VirtualMachineScaleSets
          vmSize: Standard_DS2_v2
      autoScalerProfile:
        scaleDownDelayAfterAdd: 15m
        scanInterval: 20s
      diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
      dnsPrefix: dnsprefix1
      enablePodSecurityPolicy: false
      enableRBAC: true
      kubernetesVersion: ""
      linuxProfile:
        adminUsername: azureuser
        ssh:
          publicKeys:
            - keyData: keydata
      location: location1
      networkProfile:
        loadBalancerProfile:
          managedOutboundIPs:
            count: 2
        loadBalancerSku: standard
        outboundType: loadBalancer
      resourceGroupName: rg1
      resourceName: clustername1
      servicePrincipalProfile:
        clientId: clientid
        secret: secret
      sku:
        name: Basic
        tier: Free
      tags:
        archv2: ""
        tier: production
      windowsProfile:
        adminPassword: replacePassword1234$
        adminUsername: azureuser

Create Managed Cluster with EncryptionAtHost enabled

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableEncryptionAtHost = true,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableEncryptionAtHost(true)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_encryption_at_host": True,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with FIPS enabled OS

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableFIPS = true,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = false,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableFIPS(true)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(false)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_fips": True,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with GPUMIG

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                GpuInstanceProfile = AzureNative.ContainerService.GPUInstanceProfile.MIG3g,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_ND96asr_v4",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
        {
            HttpProxy = "http://myproxy.server.com:8080",
            HttpsProxy = "https://myproxy.server.com:8080",
            NoProxy = new[]
            {
                "localhost",
                "127.0.0.1",
            },
            TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        },
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterHTTPProxyConfigArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .gpuInstanceProfile("MIG3g")
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_ND96asr_v4")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .httpProxyConfig(ManagedClusterHTTPProxyConfigArgs.builder()
                .httpProxy("http://myproxy.server.com:8080")
                .httpsProxy("https://myproxy.server.com:8080")
                .noProxy(                
                    "localhost",
                    "127.0.0.1")
                .trustedCa("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                .build())
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "gpu_instance_profile": azure_native.containerservice.GPUInstanceProfile.MIG3G,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_ND96asr_v4",
    }],
    auto_scaler_profile={
        "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={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with HTTP proxy configured

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
        {
            HttpProxy = "http://myproxy.server.com:8080",
            HttpsProxy = "https://myproxy.server.com:8080",
            NoProxy = new[]
            {
                "localhost",
                "127.0.0.1",
            },
            TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        },
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterHTTPProxyConfigArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .httpProxyConfig(ManagedClusterHTTPProxyConfigArgs.builder()
                .httpProxy("http://myproxy.server.com:8080")
                .httpsProxy("https://myproxy.server.com:8080")
                .noProxy(                
                    "localhost",
                    "127.0.0.1")
                .trustedCa("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                .build())
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with LongTermSupport

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableEncryptionAtHost = true,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        ApiServerAccessProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAPIServerAccessProfileArgs
        {
            DisableRunCommand = true,
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = AzureNative.ContainerService.ManagedClusterSKUName.Base,
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Premium,
        },
        SupportPlan = AzureNative.ContainerService.KubernetesSupportPlan.AKSLongTermSupport,
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
			AddonProfiles: containerservice.ManagedClusterAddonProfileMap{},
			AgentPoolProfiles: containerservice.ManagedClusterAgentPoolProfileArray{
				&containerservice.ManagedClusterAgentPoolProfileArgs{
					Count:                  pulumi.Int(3),
					EnableEncryptionAtHost: pulumi.Bool(true),
					EnableNodePublicIP:     pulumi.Bool(true),
					Mode:                   pulumi.String(containerservice.AgentPoolModeSystem),
					Name:                   pulumi.String("nodepool1"),
					OsType:                 pulumi.String(containerservice.OSTypeLinux),
					Type:                   pulumi.String(containerservice.AgentPoolTypeVirtualMachineScaleSets),
					VmSize:                 pulumi.String("Standard_DS2_v2"),
				},
			},
			ApiServerAccessProfile: &containerservice.ManagedClusterAPIServerAccessProfileArgs{
				DisableRunCommand: pulumi.Bool(true),
			},
			AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
				ScaleDownDelayAfterAdd: pulumi.String("15m"),
				ScanInterval:           pulumi.String("20s"),
			},
			DnsPrefix:               pulumi.String("dnsprefix1"),
			EnablePodSecurityPolicy: pulumi.Bool(true),
			EnableRBAC:              pulumi.Bool(true),
			KubernetesVersion:       pulumi.String(""),
			LinuxProfile: &containerservice.ContainerServiceLinuxProfileArgs{
				AdminUsername: pulumi.String("azureuser"),
				Ssh: &containerservice.ContainerServiceSshConfigurationArgs{
					PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
						&containerservice.ContainerServiceSshPublicKeyArgs{
							KeyData: pulumi.String("keydata"),
						},
					},
				},
			},
			Location: pulumi.String("location1"),
			NetworkProfile: &containerservice.ContainerServiceNetworkProfileArgs{
				LoadBalancerProfile: &containerservice.ManagedClusterLoadBalancerProfileArgs{
					ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
						Count: pulumi.Int(2),
					},
				},
				LoadBalancerSku: pulumi.String(containerservice.LoadBalancerSkuStandard),
				OutboundType:    pulumi.String(containerservice.OutboundTypeLoadBalancer),
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
			ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
				ClientId: pulumi.String("clientid"),
				Secret:   pulumi.String("secret"),
			},
			Sku: &containerservice.ManagedClusterSKUArgs{
				Name: pulumi.String(containerservice.ManagedClusterSKUNameBase),
				Tier: pulumi.String(containerservice.ManagedClusterSKUTierPremium),
			},
			SupportPlan: pulumi.String(containerservice.KubernetesSupportPlanAKSLongTermSupport),
			Tags: pulumi.StringMap{
				"archv2": pulumi.String(""),
				"tier":   pulumi.String("production"),
			},
			WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
				AdminPassword: pulumi.String("replacePassword1234$"),
				AdminUsername: pulumi.String("azureuser"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAPIServerAccessProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableEncryptionAtHost(true)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .apiServerAccessProfile(ManagedClusterAPIServerAccessProfileArgs.builder()
                .disableRunCommand(true)
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Base")
                .tier("Premium")
                .build())
            .supportPlan("AKSLongTermSupport")
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_encryption_at_host": True,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    api_server_access_profile={
        "disable_run_command": True,
    },
    auto_scaler_profile={
        "scale_down_delay_after_add": "15m",
        "scan_interval": "20s",
    },
    dns_prefix="dnsprefix1",
    enable_pod_security_policy=True,
    enable_rbac=True,
    kubernetes_version="",
    linux_profile={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": azure_native.containerservice.ManagedClusterSKUName.BASE,
        "tier": azure_native.containerservice.ManagedClusterSKUTier.PREMIUM,
    },
    support_plan=azure_native.containerservice.KubernetesSupportPlan.AKS_LONG_TERM_SUPPORT,
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    addonProfiles: {},
    agentPoolProfiles: [{
        count: 3,
        enableEncryptionAtHost: true,
        enableNodePublicIP: true,
        mode: azure_native.containerservice.AgentPoolMode.System,
        name: "nodepool1",
        osType: azure_native.containerservice.OSType.Linux,
        type: azure_native.containerservice.AgentPoolType.VirtualMachineScaleSets,
        vmSize: "Standard_DS2_v2",
    }],
    apiServerAccessProfile: {
        disableRunCommand: true,
    },
    autoScalerProfile: {
        scaleDownDelayAfterAdd: "15m",
        scanInterval: "20s",
    },
    dnsPrefix: "dnsprefix1",
    enablePodSecurityPolicy: true,
    enableRBAC: true,
    kubernetesVersion: "",
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "keydata",
            }],
        },
    },
    location: "location1",
    networkProfile: {
        loadBalancerProfile: {
            managedOutboundIPs: {
                count: 2,
            },
        },
        loadBalancerSku: azure_native.containerservice.LoadBalancerSku.Standard,
        outboundType: azure_native.containerservice.OutboundType.LoadBalancer,
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
    servicePrincipalProfile: {
        clientId: "clientid",
        secret: "secret",
    },
    sku: {
        name: azure_native.containerservice.ManagedClusterSKUName.Base,
        tier: azure_native.containerservice.ManagedClusterSKUTier.Premium,
    },
    supportPlan: azure_native.containerservice.KubernetesSupportPlan.AKSLongTermSupport,
    tags: {
        archv2: "",
        tier: "production",
    },
    windowsProfile: {
        adminPassword: "replacePassword1234$",
        adminUsername: "azureuser",
    },
});

resources:
  managedCluster:
    type: azure-native:containerservice:ManagedCluster
    properties:
      addonProfiles: {}
      agentPoolProfiles:
        - count: 3
          enableEncryptionAtHost: true
          enableNodePublicIP: true
          mode: System
          name: nodepool1
          osType: Linux
          type: VirtualMachineScaleSets
          vmSize: Standard_DS2_v2
      apiServerAccessProfile:
        disableRunCommand: true
      autoScalerProfile:
        scaleDownDelayAfterAdd: 15m
        scanInterval: 20s
      dnsPrefix: dnsprefix1
      enablePodSecurityPolicy: true
      enableRBAC: true
      kubernetesVersion: ""
      linuxProfile:
        adminUsername: azureuser
        ssh:
          publicKeys:
            - keyData: keydata
      location: location1
      networkProfile:
        loadBalancerProfile:
          managedOutboundIPs:
            count: 2
        loadBalancerSku: standard
        outboundType: loadBalancer
      resourceGroupName: rg1
      resourceName: clustername1
      servicePrincipalProfile:
        clientId: clientid
        secret: secret
      sku:
        name: Base
        tier: Premium
      supportPlan: AKSLongTermSupport
      tags:
        archv2: ""
        tier: production
      windowsProfile:
        adminPassword: replacePassword1234$
        adminUsername: azureuser

Create Managed Cluster with Node Public IP Prefix

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                NodePublicIPPrefixID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .nodePublicIPPrefixID("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "node_public_ip_prefix_id": "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with OSSKU

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsSKU = AzureNative.ContainerService.OSSKU.AzureLinux,
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
        {
            HttpProxy = "http://myproxy.server.com:8080",
            HttpsProxy = "https://myproxy.server.com:8080",
            NoProxy = new[]
            {
                "localhost",
                "127.0.0.1",
            },
            TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
        },
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterHTTPProxyConfigArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osSKU("AzureLinux")
                .osType("Linux")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .httpProxyConfig(ManagedClusterHTTPProxyConfigArgs.builder()
                .httpProxy("http://myproxy.server.com:8080")
                .httpsProxy("https://myproxy.server.com:8080")
                .noProxy(                
                    "localhost",
                    "127.0.0.1")
                .trustedCa("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
                .build())
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_sku": azure_native.containerservice.OSSKU.AZURE_LINUX,
        "os_type": azure_native.containerservice.OSType.LINUX,
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with PPG

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                ProximityPlacementGroupID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = AzureNative.ContainerService.LoadBalancerSku.Standard,
            OutboundType = AzureNative.ContainerService.OutboundType.LoadBalancer,
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = AzureNative.ContainerService.ManagedClusterSKUTier.Free,
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});

package main

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

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterAgentPoolProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterPropertiesAutoScalerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceLinuxProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceSshConfigurationArgs;
import com.pulumi.azurenative.containerservice.inputs.ContainerServiceNetworkProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterServicePrincipalProfileArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterSKUArgs;
import com.pulumi.azurenative.containerservice.inputs.ManagedClusterWindowsProfileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
            .addonProfiles()
            .agentPoolProfiles(ManagedClusterAgentPoolProfileArgs.builder()
                .count(3)
                .enableNodePublicIP(true)
                .mode("System")
                .name("nodepool1")
                .osType("Linux")
                .proximityPlacementGroupID("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1")
                .type("VirtualMachineScaleSets")
                .vmSize("Standard_DS2_v2")
                .build())
            .autoScalerProfile(ManagedClusterPropertiesAutoScalerProfileArgs.builder()
                .scaleDownDelayAfterAdd("15m")
                .scanInterval("20s")
                .build())
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .kubernetesVersion("")
            .linuxProfile(ContainerServiceLinuxProfileArgs.builder()
                .adminUsername("azureuser")
                .ssh(ContainerServiceSshConfigurationArgs.builder()
                    .publicKeys(ContainerServiceSshPublicKeyArgs.builder()
                        .keyData("keydata")
                        .build())
                    .build())
                .build())
            .location("location1")
            .networkProfile(ContainerServiceNetworkProfileArgs.builder()
                .loadBalancerProfile(ManagedClusterLoadBalancerProfileArgs.builder()
                    .managedOutboundIPs(ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs.builder()
                        .count(2)
                        .build())
                    .build())
                .loadBalancerSku("standard")
                .outboundType("loadBalancer")
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(ManagedClusterServicePrincipalProfileArgs.builder()
                .clientId("clientid")
                .secret("secret")
                .build())
            .sku(ManagedClusterSKUArgs.builder()
                .name("Basic")
                .tier("Free")
                .build())
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(ManagedClusterWindowsProfileArgs.builder()
                .adminPassword("replacePassword1234$")
                .adminUsername("azureuser")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
    addon_profiles={},
    agent_pool_profiles=[{
        "count": 3,
        "enable_node_public_ip": True,
        "mode": azure_native.containerservice.AgentPoolMode.SYSTEM,
        "name": "nodepool1",
        "os_type": azure_native.containerservice.OSType.LINUX,
        "proximity_placement_group_id": "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
        "type": azure_native.containerservice.AgentPoolType.VIRTUAL_MACHINE_SCALE_SETS,
        "vm_size": "Standard_DS2_v2",
    }],
    auto_scaler_profile={
        "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={
        "admin_username": "azureuser",
        "ssh": {
            "public_keys": [{
                "key_data": "keydata",
            }],
        },
    },
    location="location1",
    network_profile={
        "load_balancer_profile": {
            "managed_outbound_ips": {
                "count": 2,
            },
        },
        "load_balancer_sku": azure_native.containerservice.LoadBalancerSku.STANDARD,
        "outbound_type": azure_native.containerservice.OutboundType.LOAD_BALANCER,
    },
    resource_group_name="rg1",
    resource_name_="clustername1",
    service_principal_profile={
        "client_id": "clientid",
        "secret": "secret",
    },
    sku={
        "name": "Basic",
        "tier": azure_native.containerservice.ManagedClusterSKUTier.FREE,
    },
    tags={
        "archv2": "",
        "tier": "production",
    },
    windows_profile={
        "admin_password": "replacePassword1234$",
        "admin_username": "azureuser",
    })

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

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

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

Create Managed Cluster with PodIdentity enabled

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = null,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableNodePublicIP = true,
                Mode = AzureNative.ContainerService.AgentPoolMode.System,
                Name = "nodepool1",
                OsType = AzureNative.ContainerService.OSType.Linux,
                Type = AzureNative.ContainerService.AgentPoolType.VirtualMachineScaleSets,
                VmSize = "Standard_DS2_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },