azure-native.containerservice.ManagedCluster

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

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

});

package generated_program;

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

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

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

    }
}

import pulumi
import pulumi_azure_native as azure_native

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

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

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

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

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

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

});

package generated_program;

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

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

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

    }
}

import pulumi
import pulumi_azure_native as azure_native

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

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

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

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

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

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

});

package generated_program;

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

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

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

    }
}

import pulumi
import pulumi_azure_native as azure_native

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

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

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

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

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

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

});

package generated_program;

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

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

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

    }
}

import pulumi
import pulumi_azure_native as azure_native

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