Azure Native

Pulumi Official
Package maintained by Pulumi
v1.68.2 published on Tuesday, Aug 16, 2022 by Pulumi

ManagedCluster

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

Example Usage

Create Managed Cluster with Azure KeyVault Secrets Provider Addon

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with EncryptionAtHost enabled

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with FIPS enabled OS

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with GPUMIG

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with HTTP proxy configured

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with Node Public IP Prefix

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with OSSKU

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with PPG

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Cluster with PodIdentity enabled

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create Managed Private Cluster with fqdn subdomain specified

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

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = ,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                Count = 3,
                EnableEncryptionAtHost = true,
                EnableNodePublicIP = true,
                Mode = "System",
                Name = "nodepool1",
                OsType = "Linux",
                Type = "VirtualMachineScaleSets",
                VmSize = "Standard_DS2_v2",
            },
        },
        ApiServerAccessProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAPIServerAccessProfileArgs
        {
            EnablePrivateCluster = true,
            PrivateDNSZone = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
        },
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        FqdnSubdomain = "domain1",
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = "standard",
            OutboundType = "loadBalancer",
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = "Free",
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create/Update AAD Managed Cluster with EnableAzureRBAC

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

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

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create/Update Managed Cluster

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

return await Deployment.RunAsync(() => 
{
    var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
    {
        AddonProfiles = ,
        AgentPoolProfiles = new[]
        {
            new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
            {
                AvailabilityZones = new[]
                {
                    "1",
                    "2",
                    "3",
                },
                Count = 3,
                EnableNodePublicIP = true,
                Mode = "System",
                Name = "nodepool1",
                OsType = "Linux",
                Type = "VirtualMachineScaleSets",
                VmSize = "Standard_DS1_v2",
            },
        },
        AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
        {
            BalanceSimilarNodeGroups = "true",
            Expander = "priority",
            MaxNodeProvisionTime = "15m",
            NewPodScaleUpDelay = "1m",
            ScaleDownDelayAfterAdd = "15m",
            ScanInterval = "20s",
            SkipNodesWithSystemPods = "false",
        },
        DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
        DnsPrefix = "dnsprefix1",
        EnablePodSecurityPolicy = true,
        EnableRBAC = true,
        Identity = new AzureNative.ContainerService.Inputs.ManagedClusterIdentityArgs
        {
            Type = AzureNative.ContainerService.ResourceIdentityType.UserAssigned,
            UserAssignedIdentities = 
            {
                { "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1",  },
            },
        },
        KubernetesVersion = "",
        LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
        {
            AdminUsername = "azureuser",
            Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
            {
                PublicKeys = new[]
                {
                    new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
                    {
                        KeyData = "keydata",
                    },
                },
            },
        },
        Location = "location1",
        NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
        {
            LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
            {
                ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
                {
                    Count = 2,
                },
            },
            LoadBalancerSku = "standard",
            OutboundType = "loadBalancer",
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
        {
            ClientId = "clientid",
            Secret = "secret",
        },
        Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
        {
            Name = "Basic",
            Tier = "Free",
        },
        Tags = 
        {
            { "archv2", "" },
            { "tier", "production" },
        },
        WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
        {
            AdminPassword = "replacePassword1234$",
            AdminUsername = "azureuser",
        },
    });

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()        
            .addonProfiles()
            .agentPoolProfiles(Map.ofEntries(
                Map.entry("availabilityZones",                 
                    "1",
                    "2",
                    "3"),
                Map.entry("count", 3),
                Map.entry("enableNodePublicIP", true),
                Map.entry("mode", "System"),
                Map.entry("name", "nodepool1"),
                Map.entry("osType", "Linux"),
                Map.entry("type", "VirtualMachineScaleSets"),
                Map.entry("vmSize", "Standard_DS1_v2")
            ))
            .autoScalerProfile(Map.ofEntries(
                Map.entry("balanceSimilarNodeGroups", "true"),
                Map.entry("expander", "priority"),
                Map.entry("maxNodeProvisionTime", "15m"),
                Map.entry("newPodScaleUpDelay", "1m"),
                Map.entry("scaleDownDelayAfterAdd", "15m"),
                Map.entry("scanInterval", "20s"),
                Map.entry("skipNodesWithSystemPods", "false")
            ))
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", ))
            ))
            .kubernetesVersion("")
            .linuxProfile(Map.ofEntries(
                Map.entry("adminUsername", "azureuser"),
                Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
            ))
            .location("location1")
            .networkProfile(Map.ofEntries(
                Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                Map.entry("loadBalancerSku", "standard"),
                Map.entry("outboundType", "loadBalancer")
            ))
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(Map.ofEntries(
                Map.entry("clientId", "clientid"),
                Map.entry("secret", "secret")
            ))
            .sku(Map.ofEntries(
                Map.entry("name", "Basic"),
                Map.entry("tier", "Free")
            ))
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(Map.ofEntries(
                Map.entry("adminPassword", "replacePassword1234$"),
                Map.entry("adminUsername", "azureuser")
            ))
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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

Create/Update Managed Cluster with EnableAHUB

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

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

});
package main

import (
	"fmt"

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

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

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()        
            .addonProfiles()
            .agentPoolProfiles(Map.ofEntries(
                Map.entry("availabilityZones",                 
                    "1",
                    "2",
                    "3"),
                Map.entry("count", 3),
                Map.entry("enableNodePublicIP", true),
                Map.entry("mode", "System"),
                Map.entry("name", "nodepool1"),
                Map.entry("osType", "Linux"),
                Map.entry("type", "VirtualMachineScaleSets"),
                Map.entry("vmSize", "Standard_DS1_v2")
            ))
            .autoScalerProfile(Map.ofEntries(
                Map.entry("scaleDownDelayAfterAdd", "15m"),
                Map.entry("scanInterval", "20s")
            ))
            .diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
            .dnsPrefix("dnsprefix1")
            .enablePodSecurityPolicy(true)
            .enableRBAC(true)
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", ))
            ))
            .kubernetesVersion("")
            .linuxProfile(Map.ofEntries(
                Map.entry("adminUsername", "azureuser"),
                Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
            ))
            .location("location1")
            .networkProfile(Map.ofEntries(
                Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
                Map.entry("loadBalancerSku", "standard"),
                Map.entry("outboundType", "loadBalancer")
            ))
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .servicePrincipalProfile(Map.ofEntries(
                Map.entry("clientId", "clientid"),
                Map.entry("secret", "secret")
            ))
            .sku(Map.ofEntries(
                Map.entry("name", "Basic"),
                Map.entry("tier", "Free")
            ))
            .tags(Map.ofEntries(
                Map.entry("archv2", ""),
                Map.entry("tier", "production")
            ))
            .windowsProfile(Map.ofEntries(
                Map.entry("adminPassword", "replacePassword1234$"),
                Map.entry("adminUsername", "azureuser"),
                Map.entry("licenseType", "Windows_Server")
            ))
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

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

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