azure-native.containerservice.ManagedCluster
Explore with Pulumi AI
Managed cluster. API Version: 2021-03-01.
Example Usage
Create Managed Cluster with Azure KeyVault Secrets Provider Addon
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles =
{
{ "azureKeyvaultSecretsProvider", new AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileArgs
{
Config =
{
{ "enableSecretRotation", "true" },
},
Enabled = true,
} },
},
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles(Map.of("azureKeyvaultSecretsProvider", Map.ofEntries(
Map.entry("config", Map.of("enableSecretRotation", "true")),
Map.entry("enabled", true)
)))
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={
"azureKeyvaultSecretsProvider": azure_native.containerservice.ManagedClusterAddonProfileArgs(
config={
"enableSecretRotation": "true",
},
enabled=True,
),
},
agent_pool_profiles=[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
Create Managed Cluster with EncryptionAtHost enabled
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableEncryptionAtHost = true,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableEncryptionAtHost", true),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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
Create Managed Cluster with FIPS enabled OS
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableFIPS = true,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = false,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableFIPS", true),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(false)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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
Create Managed Cluster with GPUMIG
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
GpuInstanceProfile = "MIG3g",
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_ND96asr_v4",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
{
HttpProxy = "http://myproxy.server.com:8080",
HttpsProxy = "https://myproxy.server.com:8080",
NoProxy = new[]
{
"localhost",
"127.0.0.1",
},
TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
},
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("gpuInstanceProfile", "MIG3g"),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_ND96asr_v4")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.httpProxyConfig(Map.ofEntries(
Map.entry("httpProxy", "http://myproxy.server.com:8080"),
Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
Map.entry("noProxy",
"localhost",
"127.0.0.1"),
Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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",
))
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 System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
{
HttpProxy = "http://myproxy.server.com:8080",
HttpsProxy = "https://myproxy.server.com:8080",
NoProxy = new[]
{
"localhost",
"127.0.0.1",
},
TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
},
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.httpProxyConfig(Map.ofEntries(
Map.entry("httpProxy", "http://myproxy.server.com:8080"),
Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
Map.entry("noProxy",
"localhost",
"127.0.0.1"),
Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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,
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 System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
NodePublicIPPrefixID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("nodePublicIPPrefixID", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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,
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 System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsSKU = "CBLMariner",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
{
HttpProxy = "http://myproxy.server.com:8080",
HttpsProxy = "https://myproxy.server.com:8080",
NoProxy = new[]
{
"localhost",
"127.0.0.1",
},
TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
},
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osSKU", "CBLMariner"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.httpProxyConfig(Map.ofEntries(
Map.entry("httpProxy", "http://myproxy.server.com:8080"),
Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
Map.entry("noProxy",
"localhost",
"127.0.0.1"),
Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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,
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 System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
ProximityPlacementGroupID = "/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("proximityPlacementGroupID", "/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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,
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 System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
PodIdentityProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPodIdentityProfileArgs
{
AllowNetworkPluginKubenet = true,
Enabled = true,
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.podIdentityProfile(Map.ofEntries(
Map.entry("allowNetworkPluginKubenet", true),
Map.entry("enabled", true)
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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",
),
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 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",
},
},
ApiServerAccessProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAPIServerAccessProfileArgs
{
EnablePrivateCluster = true,
PrivateDNSZone = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io",
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
EnablePodSecurityPolicy = true,
EnableRBAC = true,
FqdnSubdomain = "domain1",
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableEncryptionAtHost", true),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.apiServerAccessProfile(Map.ofEntries(
Map.entry("enablePrivateCluster", true),
Map.entry("privateDNSZone", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.fqdnSubdomain("domain1")
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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",
}],
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 System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AadProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAADProfileArgs
{
EnableAzureRBAC = true,
Managed = true,
},
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
AvailabilityZones = new[]
{
"1",
"2",
"3",
},
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS1_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.aadProfile(Map.ofEntries(
Map.entry("enableAzureRBAC", true),
Map.entry("managed", true)
))
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("availabilityZones",
"1",
"2",
"3"),
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS1_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
aad_profile=azure_native.containerservice.ManagedClusterAADProfileArgs(
enable_azure_rbac=True,
managed=True,
),
addon_profiles={},
agent_pool_profiles=[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.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", {
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 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
{
AvailabilityZones = new[]
{
"1",
"2",
"3",
},
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS1_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
BalanceSimilarNodeGroups = "true",
Expander = "priority",
MaxNodeProvisionTime = "15m",
NewPodScaleUpDelay = "1m",
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
SkipNodesWithSystemPods = "false",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
Identity = new AzureNative.ContainerService.Inputs.ManagedClusterIdentityArgs
{
Type = AzureNative.ContainerService.ResourceIdentityType.UserAssigned,
UserAssignedIdentities =
{
{ "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", null },
},
},
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("availabilityZones",
"1",
"2",
"3"),
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS1_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("balanceSimilarNodeGroups", "true"),
Map.entry("expander", "priority"),
Map.entry("maxNodeProvisionTime", "15m"),
Map.entry("newPodScaleUpDelay", "1m"),
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s"),
Map.entry("skipNodesWithSystemPods", "false")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.identity(Map.ofEntries(
Map.entry("type", "UserAssigned"),
Map.entry("userAssignedIdentities", Map.of("/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", ))
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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: [{
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 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
{
AvailabilityZones = new[]
{
"1",
"2",
"3",
},
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS1_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
Identity = new AzureNative.ContainerService.Inputs.ManagedClusterIdentityArgs
{
Type = AzureNative.ContainerService.ResourceIdentityType.UserAssigned,
UserAssignedIdentities =
{
{ "/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", null },
},
},
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
LicenseType = "Windows_Server",
},
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("availabilityZones",
"1",
"2",
"3"),
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS1_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.identity(Map.ofEntries(
Map.entry("type", "UserAssigned"),
Map.entry("userAssignedIdentities", Map.of("/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1", ))
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser"),
Map.entry("licenseType", "Windows_Server")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[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.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",
license_type="Windows_Server",
))
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
addonProfiles: {},
agentPoolProfiles: [{
availabilityZones: [
"1",
"2",
"3",
],
count: 3,
enableNodePublicIP: true,
mode: "System",
name: "nodepool1",
osType: "Linux",
type: "VirtualMachineScaleSets",
vmSize: "Standard_DS1_v2",
}],
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: true,
enableRBAC: true,
identity: {
type: azure_native.containerservice.ResourceIdentityType.UserAssigned,
userAssignedIdentities: {
"/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
},
},
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerProfile: {
managedOutboundIPs: {
count: 2,
},
},
loadBalancerSku: "standard",
outboundType: "loadBalancer",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Basic",
tier: "Free",
},
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
licenseType: "Windows_Server",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles: {}
agentPoolProfiles:
- availabilityZones:
- '1'
- '2'
- '3'
count: 3
enableNodePublicIP: true
mode: System
name: nodepool1
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS1_v2
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: true
enableRBAC: true
identity:
type: UserAssigned
userAssignedIdentities:
/subscriptions/subid1/resourceGroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1: {}
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerProfile:
managedOutboundIPs:
count: 2
loadBalancerSku: standard
outboundType: loadBalancer
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Basic
tier: Free
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
licenseType: Windows_Server
Create ManagedCluster Resource
new ManagedCluster(name: string, args: ManagedClusterArgs, opts?: CustomResourceOptions);
@overload
def ManagedCluster(resource_name: str,
opts: Optional[ResourceOptions] = None,
aad_profile: Optional[ManagedClusterAADProfileArgs] = None,
addon_profiles: Optional[Mapping[str, ManagedClusterAddonProfileArgs]] = None,
agent_pool_profiles: Optional[Sequence[ManagedClusterAgentPoolProfileArgs]] = None,
api_server_access_profile: Optional[ManagedClusterAPIServerAccessProfileArgs] = None,
auto_scaler_profile: Optional[ManagedClusterPropertiesAutoScalerProfileArgs] = None,
auto_upgrade_profile: Optional[ManagedClusterAutoUpgradeProfileArgs] = None,
disable_local_accounts: Optional[bool] = None,
disk_encryption_set_id: Optional[str] = None,
dns_prefix: Optional[str] = None,
enable_pod_security_policy: Optional[bool] = None,
enable_rbac: Optional[bool] = None,
extended_location: Optional[ExtendedLocationArgs] = None,
fqdn_subdomain: Optional[str] = None,
http_proxy_config: Optional[ManagedClusterHTTPProxyConfigArgs] = None,
identity: Optional[ManagedClusterIdentityArgs] = None,
identity_profile: Optional[Mapping[str, ManagedClusterPropertiesIdentityProfileArgs]] = None,
kubernetes_version: Optional[str] = None,
linux_profile: Optional[ContainerServiceLinuxProfileArgs] = None,
location: Optional[str] = None,
network_profile: Optional[ContainerServiceNetworkProfileArgs] = None,
node_resource_group: Optional[str] = None,
pod_identity_profile: Optional[ManagedClusterPodIdentityProfileArgs] = None,
private_link_resources: Optional[Sequence[PrivateLinkResourceArgs]] = None,
resource_group_name: Optional[str] = None,
resource_name_: Optional[str] = None,
service_principal_profile: Optional[ManagedClusterServicePrincipalProfileArgs] = None,
sku: Optional[ManagedClusterSKUArgs] = None,
tags: Optional[Mapping[str, str]] = None,
windows_profile: Optional[ManagedClusterWindowsProfileArgs] = None)
@overload
def ManagedCluster(resource_name: str,
args: ManagedClusterArgs,
opts: Optional[ResourceOptions] = None)
func NewManagedCluster(ctx *Context, name string, args ManagedClusterArgs, opts ...ResourceOption) (*ManagedCluster, error)
public ManagedCluster(string name, ManagedClusterArgs args, CustomResourceOptions? opts = null)
public ManagedCluster(String name, ManagedClusterArgs args)
public ManagedCluster(String name, ManagedClusterArgs args, CustomResourceOptions options)
type: azure-native:containerservice:ManagedCluster
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.
- name string
- The unique name of the resource.
- args ManagedClusterArgs
- The arguments to resource properties.
- opts CustomResourceOptions
- Bag of options to control resource's behavior.
- resource_name str
- The unique name of the resource.
- args ManagedClusterArgs
- The arguments to resource properties.
- opts ResourceOptions
- Bag of options to control resource's behavior.
- ctx Context
- Context object for the current deployment.
- name string
- The unique name of the resource.
- args ManagedClusterArgs
- The arguments to resource properties.
- opts ResourceOption
- Bag of options to control resource's behavior.
- name string
- The unique name of the resource.
- args ManagedClusterArgs
- The arguments to resource properties.
- opts CustomResourceOptions
- Bag of options to control resource's behavior.
- name String
- The unique name of the resource.
- args ManagedClusterArgs
- The arguments to resource properties.
- options CustomResourceOptions
- Bag of options to control resource's behavior.
ManagedCluster Resource Properties
To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.
Inputs
The ManagedCluster resource accepts the following input properties:
- Resource
Group stringName The name of the resource group.
- Aad
Profile Pulumi.Azure Native. Container Service. Inputs. Managed Cluster AADProfile Args Profile of Azure Active Directory configuration.
- Addon
Profiles Dictionary<string, Pulumi.Azure Native. Container Service. Inputs. Managed Cluster Addon Profile Args> Profile of managed cluster add-on.
- Agent
Pool List<Pulumi.Profiles Azure Native. Container Service. Inputs. Managed Cluster Agent Pool Profile Args> Properties of the agent pool.
- Api
Server Pulumi.Access Profile Azure Native. Container Service. Inputs. Managed Cluster APIServer Access Profile Args Access profile for managed cluster API server.
- Auto
Scaler Pulumi.Profile Azure Native. Container Service. Inputs. Managed Cluster Properties Auto Scaler Profile Args Parameters to be applied to the cluster-autoscaler when enabled
- Auto
Upgrade Pulumi.Profile Azure Native. Container Service. Inputs. Managed Cluster Auto Upgrade Profile Args Profile of auto upgrade configuration.
- Disable
Local boolAccounts If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.
- Disk
Encryption stringSet ID ResourceId of the disk encryption set to use for enabling encryption at rest.
- Dns
Prefix string DNS prefix specified when creating the managed cluster.
- Enable
Pod boolSecurity Policy (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.
- Enable
RBAC bool Whether to enable Kubernetes Role-Based Access Control.
- Extended
Location Pulumi.Azure Native. Container Service. Inputs. Extended Location Args The extended location of the Virtual Machine.
- Fqdn
Subdomain string FQDN subdomain specified when creating private cluster with custom private dns zone.
- Http
Proxy Pulumi.Config Azure Native. Container Service. Inputs. Managed Cluster HTTPProxy Config Args Configurations for provisioning the cluster with HTTP proxy servers.
- Identity
Pulumi.
Azure Native. Container Service. Inputs. Managed Cluster Identity Args The identity of the managed cluster, if configured.
- Identity
Profile Dictionary<string, Pulumi.Azure Native. Container Service. Inputs. Managed Cluster Properties Identity Profile Args> Identities associated with the cluster.
- Kubernetes
Version string Version of Kubernetes specified when creating the managed cluster.
- Linux
Profile Pulumi.Azure Native. Container Service. Inputs. Container Service Linux Profile Args Profile for Linux VMs in the container service cluster.
- Location string
Resource location
- Network
Profile Pulumi.Azure Native. Container Service. Inputs. Container Service Network Profile Args Profile of network configuration.
- Node
Resource stringGroup Name of the resource group containing agent pool nodes.
- Pod
Identity Pulumi.Profile Azure Native. Container Service. Inputs. Managed Cluster Pod Identity Profile Args Profile of managed cluster pod identity.
- Private
Link List<Pulumi.Resources Azure Native. Container Service. Inputs. Private Link Resource Args> Private link resources associated with the cluster.
- Resource
Name string The name of the managed cluster resource.
- Service
Principal Pulumi.Profile Azure Native. Container Service. Inputs. Managed Cluster Service Principal Profile Args Information about a service principal identity for the cluster to use for manipulating Azure APIs.
- Sku
Pulumi.
Azure Native. Container Service. Inputs. Managed Cluster SKUArgs The managed cluster SKU.
- Dictionary<string, string>
Resource tags
- Windows
Profile Pulumi.Azure Native. Container Service. Inputs. Managed Cluster Windows Profile Args Profile for Windows VMs in the container service cluster.
- Resource
Group stringName The name of the resource group.
- Aad
Profile ManagedCluster AADProfile Args Profile of Azure Active Directory configuration.
- Addon
Profiles map[string]ManagedCluster Addon Profile Args Profile of managed cluster add-on.
- Agent
Pool []ManagedProfiles Cluster Agent Pool Profile Args Properties of the agent pool.
- Api
Server ManagedAccess Profile Cluster APIServer Access Profile Args Access profile for managed cluster API server.
- Auto
Scaler ManagedProfile Cluster Properties Auto Scaler Profile Args Parameters to be applied to the cluster-autoscaler when enabled
- Auto
Upgrade ManagedProfile Cluster Auto Upgrade Profile Args Profile of auto upgrade configuration.
- Disable
Local boolAccounts If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.
- Disk
Encryption stringSet ID ResourceId of the disk encryption set to use for enabling encryption at rest.
- Dns
Prefix string DNS prefix specified when creating the managed cluster.
- Enable
Pod boolSecurity Policy (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.
- Enable
RBAC bool Whether to enable Kubernetes Role-Based Access Control.
- Extended
Location ExtendedLocation Args The extended location of the Virtual Machine.
- Fqdn
Subdomain string FQDN subdomain specified when creating private cluster with custom private dns zone.
- Http
Proxy ManagedConfig Cluster HTTPProxy Config Args Configurations for provisioning the cluster with HTTP proxy servers.
- Identity
Managed
Cluster Identity Args The identity of the managed cluster, if configured.
- Identity
Profile map[string]ManagedCluster Properties Identity Profile Args Identities associated with the cluster.
- Kubernetes
Version string Version of Kubernetes specified when creating the managed cluster.
- Linux
Profile ContainerService Linux Profile Args Profile for Linux VMs in the container service cluster.
- Location string
Resource location
- Network
Profile ContainerService Network Profile Args Profile of network configuration.
- Node
Resource stringGroup Name of the resource group containing agent pool nodes.
- Pod
Identity ManagedProfile Cluster Pod Identity Profile Args Profile of managed cluster pod identity.
- Private
Link []PrivateResources Link Resource Args Private link resources associated with the cluster.
- Resource
Name string The name of the managed cluster resource.
- Service
Principal ManagedProfile Cluster Service Principal Profile Args Information about a service principal identity for the cluster to use for manipulating Azure APIs.
- Sku
Managed
Cluster SKUArgs The managed cluster SKU.
- map[string]string
Resource tags
- Windows
Profile ManagedCluster Windows Profile Args Profile for Windows VMs in the container service cluster.
- resource
Group StringName The name of the resource group.
- aad
Profile ManagedCluster AADProfile Args Profile of Azure Active Directory configuration.
- addon
Profiles Map<String,ManagedCluster Addon Profile Args> Profile of managed cluster add-on.
- agent
Pool List<ManagedProfiles Cluster Agent Pool Profile Args> Properties of the agent pool.
- api
Server ManagedAccess Profile Cluster APIServer Access Profile Args Access profile for managed cluster API server.
- auto
Scaler ManagedProfile Cluster Properties Auto Scaler Profile Args Parameters to be applied to the cluster-autoscaler when enabled
- auto
Upgrade ManagedProfile Cluster Auto Upgrade Profile Args Profile of auto upgrade configuration.
- disable
Local BooleanAccounts If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.
- disk
Encryption StringSet ID ResourceId of the disk encryption set to use for enabling encryption at rest.
- dns
Prefix String DNS prefix specified when creating the managed cluster.
- enable
Pod BooleanSecurity Policy (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.
- enable
RBAC Boolean Whether to enable Kubernetes Role-Based Access Control.
- extended
Location ExtendedLocation Args The extended location of the Virtual Machine.
- fqdn
Subdomain String FQDN subdomain specified when creating private cluster with custom private dns zone.
- http
Proxy ManagedConfig Cluster HTTPProxy Config Args Configurations for provisioning the cluster with HTTP proxy servers.
- identity
Managed
Cluster Identity Args The identity of the managed cluster, if configured.
- identity
Profile Map<String,ManagedCluster Properties Identity Profile Args> Identities associated with the cluster.
- kubernetes
Version String Version of Kubernetes specified when creating the managed cluster.
- linux
Profile ContainerService Linux Profile Args Profile for Linux VMs in the container service cluster.
- location String
Resource location
- network
Profile ContainerService Network Profile Args Profile of network configuration.
- node
Resource StringGroup Name of the resource group containing agent pool nodes.
- pod
Identity ManagedProfile Cluster Pod Identity Profile Args Profile of managed cluster pod identity.
- private
Link List<PrivateResources Link Resource Args> Private link resources associated with the cluster.
- resource
Name String The name of the managed cluster resource.
- service
Principal ManagedProfile Cluster Service Principal Profile Args Information about a service principal identity for the cluster to use for manipulating Azure APIs.
- sku
Managed
Cluster SKUArgs The managed cluster SKU.
- Map<String,String>
Resource tags
- windows
Profile ManagedCluster Windows Profile Args Profile for Windows VMs in the container service cluster.
- resource
Group stringName The name of the resource group.
- aad
Profile ManagedCluster AADProfile Args Profile of Azure Active Directory configuration.
- addon
Profiles {[key: string]: ManagedCluster Addon Profile Args} Profile of managed cluster add-on.
- agent
Pool ManagedProfiles Cluster Agent Pool Profile Args[] Properties of the agent pool.
- api
Server ManagedAccess Profile Cluster APIServer Access Profile Args Access profile for managed cluster API server.
- auto
Scaler ManagedProfile Cluster Properties Auto Scaler Profile Args Parameters to be applied to the cluster-autoscaler when enabled
- auto
Upgrade ManagedProfile Cluster Auto Upgrade Profile Args Profile of auto upgrade configuration.
- disable
Local booleanAccounts If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.
- disk
Encryption stringSet ID ResourceId of the disk encryption set to use for enabling encryption at rest.
- dns
Prefix string DNS prefix specified when creating the managed cluster.
- enable
Pod booleanSecurity Policy (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.
- enable
RBAC boolean Whether to enable Kubernetes Role-Based Access Control.
- extended
Location ExtendedLocation Args The extended location of the Virtual Machine.
- fqdn
Subdomain string FQDN subdomain specified when creating private cluster with custom private dns zone.
- http
Proxy ManagedConfig Cluster HTTPProxy Config Args Configurations for provisioning the cluster with HTTP proxy servers.
- identity
Managed
Cluster Identity Args The identity of the managed cluster, if configured.
- identity
Profile {[key: string]: ManagedCluster Properties Identity Profile Args} Identities associated with the cluster.
- kubernetes
Version string Version of Kubernetes specified when creating the managed cluster.
- linux
Profile ContainerService Linux Profile Args Profile for Linux VMs in the container service cluster.
- location string
Resource location
- network
Profile ContainerService Network Profile Args Profile of network configuration.
- node
Resource stringGroup Name of the resource group containing agent pool nodes.
- pod
Identity ManagedProfile Cluster Pod Identity Profile Args Profile of managed cluster pod identity.
- private
Link PrivateResources Link Resource Args[] Private link resources associated with the cluster.
- resource
Name string The name of the managed cluster resource.
- service
Principal ManagedProfile Cluster Service Principal Profile Args Information about a service principal identity for the cluster to use for manipulating Azure APIs.
- sku
Managed
Cluster SKUArgs The managed cluster SKU.
- {[key: string]: string}
Resource tags
- windows
Profile ManagedCluster Windows Profile Args Profile for Windows VMs in the container service cluster.
- resource_
group_ strname The name of the resource group.
- aad_
profile ManagedCluster AADProfile Args Profile of Azure Active Directory configuration.
- addon_
profiles Mapping[str, ManagedCluster Addon Profile Args] Profile of managed cluster add-on.
- agent_
pool_ Sequence[Managedprofiles Cluster Agent Pool Profile Args] Properties of the agent pool.
- api_
server_ Managedaccess_ profile Cluster APIServer Access Profile Args Access profile for managed cluster API server.
- auto_
scaler_ Managedprofile Cluster Properties Auto Scaler Profile Args Parameters to be applied to the cluster-autoscaler when enabled
- auto_
upgrade_ Managedprofile Cluster Auto Upgrade Profile Args Profile of auto upgrade configuration.
- disable_
local_ boolaccounts If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.
- disk_
encryption_ strset_ id ResourceId of the disk encryption set to use for enabling encryption at rest.
- dns_
prefix str DNS prefix specified when creating the managed cluster.
- enable_
pod_ boolsecurity_ policy (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.
- enable_
rbac bool Whether to enable Kubernetes Role-Based Access Control.
- extended_
location ExtendedLocation Args The extended location of the Virtual Machine.
- fqdn_
subdomain str FQDN subdomain specified when creating private cluster with custom private dns zone.
- http_
proxy_ Managedconfig Cluster HTTPProxy Config Args Configurations for provisioning the cluster with HTTP proxy servers.
- identity
Managed
Cluster Identity Args The identity of the managed cluster, if configured.
- identity_
profile Mapping[str, ManagedCluster Properties Identity Profile Args] Identities associated with the cluster.
- kubernetes_
version str Version of Kubernetes specified when creating the managed cluster.
- linux_
profile ContainerService Linux Profile Args Profile for Linux VMs in the container service cluster.
- location str
Resource location
- network_
profile ContainerService Network Profile Args Profile of network configuration.
- node_
resource_ strgroup Name of the resource group containing agent pool nodes.
- pod_
identity_ Managedprofile Cluster Pod Identity Profile Args Profile of managed cluster pod identity.
- private_
link_ Sequence[Privateresources Link Resource Args] Private link resources associated with the cluster.
- resource_
name str The name of the managed cluster resource.
- service_
principal_ Managedprofile Cluster Service Principal Profile Args Information about a service principal identity for the cluster to use for manipulating Azure APIs.
- sku
Managed
Cluster SKUArgs The managed cluster SKU.
- Mapping[str, str]
Resource tags
- windows_
profile ManagedCluster Windows Profile Args Profile for Windows VMs in the container service cluster.
- resource
Group StringName The name of the resource group.
- aad
Profile Property Map Profile of Azure Active Directory configuration.
- addon
Profiles Map<Property Map> Profile of managed cluster add-on.
- agent
Pool List<Property Map>Profiles Properties of the agent pool.
- api
Server Property MapAccess Profile Access profile for managed cluster API server.
- auto
Scaler Property MapProfile Parameters to be applied to the cluster-autoscaler when enabled
- auto
Upgrade Property MapProfile Profile of auto upgrade configuration.
- disable
Local BooleanAccounts If set to true, getting static credential will be disabled for this cluster. Expected to only be used for AAD clusters.
- disk
Encryption StringSet ID ResourceId of the disk encryption set to use for enabling encryption at rest.
- dns
Prefix String DNS prefix specified when creating the managed cluster.
- enable
Pod BooleanSecurity Policy (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th, 2020. Learn more at aka.ms/aks/azpodpolicy.
- enable
RBAC Boolean Whether to enable Kubernetes Role-Based Access Control.
- extended
Location Property Map The extended location of the Virtual Machine.
- fqdn
Subdomain String FQDN subdomain specified when creating private cluster with custom private dns zone.
- http
Proxy Property MapConfig Configurations for provisioning the cluster with HTTP proxy servers.
- identity Property Map
The identity of the managed cluster, if configured.
- identity
Profile Map<Property Map> Identities associated with the cluster.
- kubernetes
Version String Version of Kubernetes specified when creating the managed cluster.
- linux
Profile Property Map Profile for Linux VMs in the container service cluster.
- location String
Resource location
- network
Profile Property Map Profile of network configuration.
- node
Resource StringGroup Name of the resource group containing agent pool nodes.
- pod
Identity Property MapProfile Profile of managed cluster pod identity.
- private
Link List<Property Map>Resources Private link resources associated with the cluster.
- resource
Name String The name of the managed cluster resource.
- service
Principal Property MapProfile Information about a service principal identity for the cluster to use for manipulating Azure APIs.
- sku Property Map
The managed cluster SKU.
- Map<String>
Resource tags
- windows
Profile Property Map Profile for Windows VMs in the container service cluster.
Outputs
All input properties are implicitly available as output properties. Additionally, the ManagedCluster resource produces the following output properties:
- Azure
Portal stringFQDN FQDN for the master pool which used by proxy config.
- Fqdn string
FQDN for the master pool.
- Id string
The provider-assigned unique ID for this managed resource.
- Max
Agent intPools The max number of agent pools for the managed cluster.
- Name string
Resource name
- Power
State Pulumi.Azure Native. Container Service. Outputs. Power State Response Represents the Power State of the cluster
- Private
FQDN string FQDN of private cluster.
- Provisioning
State string The current deployment or provisioning state, which only appears in the response.
- Type string
Resource type
- Azure
Portal stringFQDN FQDN for the master pool which used by proxy config.
- Fqdn string
FQDN for the master pool.
- Id string
The provider-assigned unique ID for this managed resource.
- Max
Agent intPools The max number of agent pools for the managed cluster.
- Name string
Resource name
- Power
State PowerState Response Represents the Power State of the cluster
- Private
FQDN string FQDN of private cluster.
- Provisioning
State string The current deployment or provisioning state, which only appears in the response.
- Type string
Resource type
- azure
Portal StringFQDN FQDN for the master pool which used by proxy config.
- fqdn String
FQDN for the master pool.
- id String
The provider-assigned unique ID for this managed resource.
- max
Agent IntegerPools The max number of agent pools for the managed cluster.
- name String
Resource name
- power
State PowerState Response Represents the Power State of the cluster
- private
FQDN String FQDN of private cluster.
- provisioning
State String The current deployment or provisioning state, which only appears in the response.
- type String
Resource type
- azure
Portal stringFQDN FQDN for the master pool which used by proxy config.
- fqdn string
FQDN for the master pool.
- id string
The provider-assigned unique ID for this managed resource.
- max
Agent numberPools The max number of agent pools for the managed cluster.
- name string
Resource name
- power
State PowerState Response Represents the Power State of the cluster
- private
FQDN string FQDN of private cluster.
- provisioning
State string The current deployment or provisioning state, which only appears in the response.
- type string
Resource type
- azure_
portal_ strfqdn FQDN for the master pool which used by proxy config.
- fqdn str
FQDN for the master pool.
- id str
The provider-assigned unique ID for this managed resource.
- max_
agent_ intpools The max number of agent pools for the managed cluster.
- name str
Resource name
- power_
state PowerState Response Represents the Power State of the cluster
- private_
fqdn str FQDN of private cluster.
- provisioning_
state str The current deployment or provisioning state, which only appears in the response.
- type str
Resource type
- azure
Portal StringFQDN FQDN for the master pool which used by proxy config.
- fqdn String
FQDN for the master pool.
- id String
The provider-assigned unique ID for this managed resource.
- max
Agent NumberPools The max number of agent pools for the managed cluster.
- name String
Resource name
- power
State Property Map Represents the Power State of the cluster
- private
FQDN String FQDN of private cluster.
- provisioning
State String The current deployment or provisioning state, which only appears in the response.
- type String
Resource type
Supporting Types
AgentPoolMode
- System
- System
- User
- User
- Agent
Pool Mode System - System
- Agent
Pool Mode User - User
- System
- System
- User
- User
- System
- System
- User
- User
- SYSTEM
- System
- USER
- User
- "System"
- System
- "User"
- User
AgentPoolType
- Virtual
Machine Scale Sets - VirtualMachineScaleSets
- Availability
Set - AvailabilitySet
- Agent
Pool Type Virtual Machine Scale Sets - VirtualMachineScaleSets
- Agent
Pool Type Availability Set - AvailabilitySet
- Virtual
Machine Scale Sets - VirtualMachineScaleSets
- Availability
Set - AvailabilitySet
- Virtual
Machine Scale Sets - VirtualMachineScaleSets
- Availability
Set - AvailabilitySet
- VIRTUAL_MACHINE_SCALE_SETS
- VirtualMachineScaleSets
- AVAILABILITY_SET
- AvailabilitySet
- "Virtual
Machine Scale Sets" - VirtualMachineScaleSets
- "Availability
Set" - AvailabilitySet
AgentPoolUpgradeSettings
- Max
Surge string Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- Max
Surge string Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max
Surge String Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max
Surge string Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max_
surge str Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max
Surge String Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
AgentPoolUpgradeSettingsResponse
- Max
Surge string Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- Max
Surge string Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max
Surge String Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max
Surge string Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max_
surge str Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
- max
Surge String Count or percentage of additional nodes to be added during upgrade. If empty uses AKS default
CloudErrorBodyResponse
- Code string
An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
- Details
List<Pulumi.
Azure Native. Container Service. Inputs. Cloud Error Body Response> A list of additional details about the error.
- Message string
A message describing the error, intended to be suitable for display in a user interface.
- Target string
The target of the particular error. For example, the name of the property in error.
- Code string
An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
- Details
[]Cloud
Error Body Response A list of additional details about the error.
- Message string
A message describing the error, intended to be suitable for display in a user interface.
- Target string
The target of the particular error. For example, the name of the property in error.
- code String
An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
- details
List<Cloud
Error Body Response> A list of additional details about the error.
- message String
A message describing the error, intended to be suitable for display in a user interface.
- target String
The target of the particular error. For example, the name of the property in error.
- code string
An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
- details
Cloud
Error Body Response[] A list of additional details about the error.
- message string
A message describing the error, intended to be suitable for display in a user interface.
- target string
The target of the particular error. For example, the name of the property in error.
- code str
An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
- details
Sequence[Cloud
Error Body Response] A list of additional details about the error.
- message str
A message describing the error, intended to be suitable for display in a user interface.
- target str
The target of the particular error. For example, the name of the property in error.
- code String
An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
- details List<Property Map>
A list of additional details about the error.
- message String
A message describing the error, intended to be suitable for display in a user interface.
- target String
The target of the particular error. For example, the name of the property in error.
CloudErrorResponse
- Error
Pulumi.
Azure Native. Container Service. Inputs. Cloud Error Body Response Details about the error.
- Error
Cloud
Error Body Response Details about the error.
- error
Cloud
Error Body Response Details about the error.
- error
Cloud
Error Body Response Details about the error.
- error
Cloud
Error Body Response Details about the error.
- error Property Map
Details about the error.
ContainerServiceLinuxProfile
- Admin
Username string The administrator username to use for Linux VMs.
- Ssh
Pulumi.
Azure Native. Container Service. Inputs. Container Service Ssh Configuration SSH configuration for Linux-based VMs running on Azure.
- Admin
Username string The administrator username to use for Linux VMs.
- Ssh
Container
Service Ssh Configuration SSH configuration for Linux-based VMs running on Azure.
- admin
Username String The administrator username to use for Linux VMs.
- ssh
Container
Service Ssh Configuration SSH configuration for Linux-based VMs running on Azure.
- admin
Username string The administrator username to use for Linux VMs.
- ssh
Container
Service Ssh Configuration SSH configuration for Linux-based VMs running on Azure.
- admin_
username str The administrator username to use for Linux VMs.
- ssh
Container
Service Ssh Configuration SSH configuration for Linux-based VMs running on Azure.
- admin
Username String The administrator username to use for Linux VMs.
- ssh Property Map
SSH configuration for Linux-based VMs running on Azure.
ContainerServiceLinuxProfileResponse
- Admin
Username string The administrator username to use for Linux VMs.
- Ssh
Pulumi.
Azure Native. Container Service. Inputs. Container Service Ssh Configuration Response SSH configuration for Linux-based VMs running on Azure.
- Admin
Username string The administrator username to use for Linux VMs.
- Ssh
Container
Service Ssh Configuration Response SSH configuration for Linux-based VMs running on Azure.
- admin
Username String The administrator username to use for Linux VMs.
- ssh
Container
Service Ssh Configuration Response SSH configuration for Linux-based VMs running on Azure.
- admin
Username string The administrator username to use for Linux VMs.
- ssh
Container
Service Ssh Configuration Response SSH configuration for Linux-based VMs running on Azure.
- admin_
username str The administrator username to use for Linux VMs.
- ssh
Container
Service Ssh Configuration Response SSH configuration for Linux-based VMs running on Azure.
- admin
Username String The administrator username to use for Linux VMs.
- ssh Property Map
SSH configuration for Linux-based VMs running on Azure.
ContainerServiceNetworkProfile
- Dns
Service stringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- Docker
Bridge stringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- Load
Balancer Pulumi.Profile Azure Native. Container Service. Inputs. Managed Cluster Load Balancer Profile Profile of the cluster load balancer.
- Load
Balancer string | Pulumi.Sku Azure Native. Container Service. Load Balancer Sku The load balancer sku for the managed cluster.
- Network
Mode string | Pulumi.Azure Native. Container Service. Network Mode Network mode used for building Kubernetes network.
- Network
Plugin string | Pulumi.Azure Native. Container Service. Network Plugin Network plugin used for building Kubernetes network.
- Network
Policy string | Pulumi.Azure Native. Container Service. Network Policy Network policy used for building Kubernetes network.
- Outbound
Type string | Pulumi.Azure Native. Container Service. Outbound Type The outbound (egress) routing method.
- Pod
Cidr string A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- Service
Cidr string A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- Dns
Service stringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- Docker
Bridge stringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- Load
Balancer ManagedProfile Cluster Load Balancer Profile Profile of the cluster load balancer.
- Load
Balancer string | LoadSku Balancer Sku The load balancer sku for the managed cluster.
- Network
Mode string | NetworkMode Network mode used for building Kubernetes network.
- Network
Plugin string | NetworkPlugin Network plugin used for building Kubernetes network.
- Network
Policy string | NetworkPolicy Network policy used for building Kubernetes network.
- Outbound
Type string | OutboundType The outbound (egress) routing method.
- Pod
Cidr string A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- Service
Cidr string A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns
Service StringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker
Bridge StringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load
Balancer ManagedProfile Cluster Load Balancer Profile Profile of the cluster load balancer.
- load
Balancer String | LoadSku Balancer Sku The load balancer sku for the managed cluster.
- network
Mode String | NetworkMode Network mode used for building Kubernetes network.
- network
Plugin String | NetworkPlugin Network plugin used for building Kubernetes network.
- network
Policy String | NetworkPolicy Network policy used for building Kubernetes network.
- outbound
Type String | OutboundType The outbound (egress) routing method.
- pod
Cidr String A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service
Cidr String A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns
Service stringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker
Bridge stringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load
Balancer ManagedProfile Cluster Load Balancer Profile Profile of the cluster load balancer.
- load
Balancer string | LoadSku Balancer Sku The load balancer sku for the managed cluster.
- network
Mode string | NetworkMode Network mode used for building Kubernetes network.
- network
Plugin string | NetworkPlugin Network plugin used for building Kubernetes network.
- network
Policy string | NetworkPolicy Network policy used for building Kubernetes network.
- outbound
Type string | OutboundType The outbound (egress) routing method.
- pod
Cidr string A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service
Cidr string A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns_
service_ strip An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker_
bridge_ strcidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load_
balancer_ Managedprofile Cluster Load Balancer Profile Profile of the cluster load balancer.
- load_
balancer_ str | Loadsku Balancer Sku The load balancer sku for the managed cluster.
- network_
mode str | NetworkMode Network mode used for building Kubernetes network.
- network_
plugin str | NetworkPlugin Network plugin used for building Kubernetes network.
- network_
policy str | NetworkPolicy Network policy used for building Kubernetes network.
- outbound_
type str | OutboundType The outbound (egress) routing method.
- pod_
cidr str A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service_
cidr str A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns
Service StringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker
Bridge StringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load
Balancer Property MapProfile Profile of the cluster load balancer.
- load
Balancer String | "standard" | "basic"Sku The load balancer sku for the managed cluster.
- network
Mode String | "transparent" | "bridge" Network mode used for building Kubernetes network.
- network
Plugin String | "azure" | "kubenet" Network plugin used for building Kubernetes network.
- network
Policy String | "calico" | "azure" Network policy used for building Kubernetes network.
- outbound
Type String | "loadBalancer" | "user Defined Routing" The outbound (egress) routing method.
- pod
Cidr String A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service
Cidr String A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
ContainerServiceNetworkProfileResponse
- Dns
Service stringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- Docker
Bridge stringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- Load
Balancer Pulumi.Profile Azure Native. Container Service. Inputs. Managed Cluster Load Balancer Profile Response Profile of the cluster load balancer.
- Load
Balancer stringSku The load balancer sku for the managed cluster.
- Network
Mode string Network mode used for building Kubernetes network.
- Network
Plugin string Network plugin used for building Kubernetes network.
- Network
Policy string Network policy used for building Kubernetes network.
- Outbound
Type string The outbound (egress) routing method.
- Pod
Cidr string A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- Service
Cidr string A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- Dns
Service stringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- Docker
Bridge stringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- Load
Balancer ManagedProfile Cluster Load Balancer Profile Response Profile of the cluster load balancer.
- Load
Balancer stringSku The load balancer sku for the managed cluster.
- Network
Mode string Network mode used for building Kubernetes network.
- Network
Plugin string Network plugin used for building Kubernetes network.
- Network
Policy string Network policy used for building Kubernetes network.
- Outbound
Type string The outbound (egress) routing method.
- Pod
Cidr string A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- Service
Cidr string A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns
Service StringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker
Bridge StringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load
Balancer ManagedProfile Cluster Load Balancer Profile Response Profile of the cluster load balancer.
- load
Balancer StringSku The load balancer sku for the managed cluster.
- network
Mode String Network mode used for building Kubernetes network.
- network
Plugin String Network plugin used for building Kubernetes network.
- network
Policy String Network policy used for building Kubernetes network.
- outbound
Type String The outbound (egress) routing method.
- pod
Cidr String A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service
Cidr String A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns
Service stringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker
Bridge stringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load
Balancer ManagedProfile Cluster Load Balancer Profile Response Profile of the cluster load balancer.
- load
Balancer stringSku The load balancer sku for the managed cluster.
- network
Mode string Network mode used for building Kubernetes network.
- network
Plugin string Network plugin used for building Kubernetes network.
- network
Policy string Network policy used for building Kubernetes network.
- outbound
Type string The outbound (egress) routing method.
- pod
Cidr string A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service
Cidr string A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns_
service_ strip An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker_
bridge_ strcidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load_
balancer_ Managedprofile Cluster Load Balancer Profile Response Profile of the cluster load balancer.
- load_
balancer_ strsku The load balancer sku for the managed cluster.
- network_
mode str Network mode used for building Kubernetes network.
- network_
plugin str Network plugin used for building Kubernetes network.
- network_
policy str Network policy used for building Kubernetes network.
- outbound_
type str The outbound (egress) routing method.
- pod_
cidr str A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service_
cidr str A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
- dns
Service StringIP An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.
- docker
Bridge StringCidr A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.
- load
Balancer Property MapProfile Profile of the cluster load balancer.
- load
Balancer StringSku The load balancer sku for the managed cluster.
- network
Mode String Network mode used for building Kubernetes network.
- network
Plugin String Network plugin used for building Kubernetes network.
- network
Policy String Network policy used for building Kubernetes network.
- outbound
Type String The outbound (egress) routing method.
- pod
Cidr String A CIDR notation IP range from which to assign pod IPs when kubenet is used.
- service
Cidr String A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
ContainerServiceSshConfiguration
- Public
Keys List<Pulumi.Azure Native. Container Service. Inputs. Container Service Ssh Public Key> The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- Public
Keys []ContainerService Ssh Public Key The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public
Keys List<ContainerService Ssh Public Key> The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public
Keys ContainerService Ssh Public Key[] The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public_
keys Sequence[ContainerService Ssh Public Key] The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public
Keys List<Property Map> The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
ContainerServiceSshConfigurationResponse
- Public
Keys List<Pulumi.Azure Native. Container Service. Inputs. Container Service Ssh Public Key Response> The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- Public
Keys []ContainerService Ssh Public Key Response The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public
Keys List<ContainerService Ssh Public Key Response> The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public
Keys ContainerService Ssh Public Key Response[] The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public_
keys Sequence[ContainerService Ssh Public Key Response] The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
- public
Keys List<Property Map> The list of SSH public keys used to authenticate with Linux-based VMs. Only expect one key specified.
ContainerServiceSshPublicKey
- Key
Data string Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- Key
Data string Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key
Data String Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key
Data string Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key_
data str Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key
Data String Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
ContainerServiceSshPublicKeyResponse
- Key
Data string Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- Key
Data string Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key
Data String Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key
Data string Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key_
data str Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
- key
Data String Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
Expander
- Least_
waste - least-waste
- Most_
pods - most-pods
- Priority
- priority
- Random
- random
- Expander_Least_Waste
- least-waste
- Expander_Most_Pods
- most-pods
- Expander
Priority - priority
- Expander
Random - random
- Leastwaste
- least-waste
- Mostpods
- most-pods
- Priority
- priority
- Random
- random
- Least_
waste - least-waste
- Most_
pods - most-pods
- Priority
- priority
- Random
- random
- LEAST_WASTE
- least-waste
- MOST_PODS
- most-pods
- PRIORITY
- priority
- RANDOM
- random
- "least-waste"
- least-waste
- "most-pods"
- most-pods
- "priority"
- priority
- "random"
- random
ExtendedLocation
- Name string
The name of the extended location.