Docs
Packages
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.9.0 published on Wednesday, Sep 27, 2023 by Pulumi
azure-native.containerservice.ManagedCluster
Explore with Pulumi AI
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.9.0 published on Wednesday, Sep 27, 2023 by Pulumi
Managed cluster. Azure REST API version: 2023-04-01. Prior API version in Azure Native 1.x: 2021-03-01
Example Usage
Create Managed Cluster using an agent pool snapshot
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
CreationData = new AzureNative.ContainerService.Inputs.CreationDataArgs
{
SourceResourceId = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
},
EnableFIPS = true,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = false,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
CreationData: {
SourceResourceId: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
},
EnableFIPS: pulumi.Bool(true),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(false),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("creationData", Map.of("sourceResourceId", "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1")),
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=[{
"count": 3,
"creationData": azure_native.containerservice.CreationDataArgs(
source_resource_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
),
"enableFIPS": True,
"enableNodePublicIP": True,
"mode": "System",
"name": "nodepool1",
"osType": "Linux",
"type": "VirtualMachineScaleSets",
"vmSize": "Standard_DS2_v2",
}],
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,
creationData: {
sourceResourceId: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1",
},
enableFIPS: true,
enableNodePublicIP: true,
mode: "System",
name: "nodepool1",
osType: "Linux",
type: "VirtualMachineScaleSets",
vmSize: "Standard_DS2_v2",
}],
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: false,
enableRBAC: true,
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerProfile: {
managedOutboundIPs: {
count: 2,
},
},
loadBalancerSku: "standard",
outboundType: "loadBalancer",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Basic",
tier: "Free",
},
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles: {}
agentPoolProfiles:
- count: 3
creationData:
sourceResourceId: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1
enableFIPS: true
enableNodePublicIP: true
mode: System
name: nodepool1
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS2_v2
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: false
enableRBAC: true
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerProfile:
managedOutboundIPs:
count: 2
loadBalancerSku: standard
outboundType: loadBalancer
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Basic
tier: Free
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
Create Managed Cluster with AKS-managed NAT gateway as outbound type
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = false,
Mode = "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
{
LoadBalancerSku = "standard",
NatGatewayProfile = new AzureNative.ContainerService.Inputs.ManagedClusterNATGatewayProfileArgs
{
ManagedOutboundIPProfile = new AzureNative.ContainerService.Inputs.ManagedClusterManagedOutboundIPProfileArgs
{
Count = 2,
},
},
OutboundType = "managedNATGateway",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(false),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerSku: pulumi.String("standard"),
NatGatewayProfile: interface{}{
ManagedOutboundIPProfile: &containerservice.ManagedClusterManagedOutboundIPProfileArgs{
Count: pulumi.Int(2),
},
},
OutboundType: pulumi.String("managedNATGateway"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", false),
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("loadBalancerSku", "standard"),
Map.entry("natGatewayProfile", Map.of("managedOutboundIPProfile", Map.of("count", 2))),
Map.entry("outboundType", "managedNATGateway")
))
.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=False,
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_sku="standard",
nat_gateway_profile={
"managedOutboundIPProfile": azure_native.containerservice.ManagedClusterManagedOutboundIPProfileArgs(
count=2,
),
},
outbound_type="managedNATGateway",
),
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: false,
mode: "System",
name: "nodepool1",
osType: "Linux",
type: "VirtualMachineScaleSets",
vmSize: "Standard_DS2_v2",
}],
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: true,
enableRBAC: true,
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerSku: "standard",
natGatewayProfile: {
managedOutboundIPProfile: {
count: 2,
},
},
outboundType: "managedNATGateway",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Basic",
tier: "Free",
},
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles: {}
agentPoolProfiles:
- count: 3
enableNodePublicIP: false
mode: System
name: nodepool1
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS2_v2
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: true
enableRBAC: true
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerSku: standard
natGatewayProfile:
managedOutboundIPProfile:
count: 2
outboundType: managedNATGateway
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Basic
tier: Free
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
Create Managed Cluster with Azure KeyVault Secrets Provider Addon
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles =
{
{ "azureKeyvaultSecretsProvider", new AzureNative.ContainerService.Inputs.ManagedClusterAddonProfileArgs
{
Config =
{
{ "enableSecretRotation", "true" },
{ "rotationPollInterval", "2m" },
},
Enabled = true,
} },
},
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: containerservice.ManagedClusterAddonProfileMap{
"azureKeyvaultSecretsProvider": &containerservice.ManagedClusterAddonProfileArgs{
Config: pulumi.StringMap{
"enableSecretRotation": pulumi.String("true"),
"rotationPollInterval": pulumi.String("2m"),
},
Enabled: pulumi.Bool(true),
},
},
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles(Map.of("azureKeyvaultSecretsProvider", Map.ofEntries(
Map.entry("config", Map.ofEntries(
Map.entry("enableSecretRotation", "true"),
Map.entry("rotationPollInterval", "2m")
)),
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",
"rotationPollInterval": "2m",
},
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",
rotationPollInterval: "2m",
},
enabled: true,
},
},
agentPoolProfiles: [{
count: 3,
enableNodePublicIP: true,
mode: "System",
name: "nodepool1",
osType: "Linux",
type: "VirtualMachineScaleSets",
vmSize: "Standard_DS2_v2",
}],
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: true,
enableRBAC: true,
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerProfile: {
managedOutboundIPs: {
count: 2,
},
},
loadBalancerSku: "standard",
outboundType: "loadBalancer",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Basic",
tier: "Free",
},
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles:
azureKeyvaultSecretsProvider:
config:
enableSecretRotation: 'true'
rotationPollInterval: 2m
enabled: true
agentPoolProfiles:
- count: 3
enableNodePublicIP: true
mode: System
name: nodepool1
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS2_v2
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: true
enableRBAC: true
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerProfile:
managedOutboundIPs:
count: 2
loadBalancerSku: standard
outboundType: loadBalancer
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Basic
tier: Free
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
Create Managed Cluster with Dedicated Host Group
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
HostGroupID = "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = false,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
HostGroupID: pulumi.String("/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(false),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("hostGroupID", "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
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_node_public_ip=True,
host_group_id="/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
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,
enableNodePublicIP: true,
hostGroupID: "/subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1",
name: "nodepool1",
osType: "Linux",
type: "VirtualMachineScaleSets",
vmSize: "Standard_DS2_v2",
}],
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: false,
enableRBAC: true,
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerProfile: {
managedOutboundIPs: {
count: 2,
},
},
loadBalancerSku: "standard",
outboundType: "loadBalancer",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Basic",
tier: "Free",
},
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles: {}
agentPoolProfiles:
- count: 3
enableNodePublicIP: true
hostGroupID: /subscriptions/subid1/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1
name: nodepool1
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS2_v2
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: false
enableRBAC: true
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerProfile:
managedOutboundIPs:
count: 2
loadBalancerSku: standard
outboundType: loadBalancer
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Basic
tier: Free
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
Create Managed Cluster with EncryptionAtHost enabled
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableEncryptionAtHost = true,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableEncryptionAtHost: pulumi.Bool(true),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableEncryptionAtHost", true),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_encryption_at_host=True,
enable_node_public_ip=True,
mode="System",
name="nodepool1",
os_type="Linux",
type="VirtualMachineScaleSets",
vm_size="Standard_DS2_v2",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=True,
enable_rbac=True,
kubernetes_version="",
linux_profile=azure_native.containerservice.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",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableFIPS: pulumi.Bool(true),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(false),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableFIPS", true),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(false)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_fips=True,
enable_node_public_ip=True,
mode="System",
name="nodepool1",
os_type="Linux",
type="VirtualMachineScaleSets",
vm_size="Standard_DS2_v2",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=False,
enable_rbac=True,
kubernetes_version="",
linux_profile=azure_native.containerservice.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",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
GpuInstanceProfile: pulumi.String("MIG3g"),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_ND96asr_v4"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
HttpProxy: pulumi.String("http://myproxy.server.com:8080"),
HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
NoProxy: pulumi.StringArray{
pulumi.String("localhost"),
pulumi.String("127.0.0.1"),
},
TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
},
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("gpuInstanceProfile", "MIG3g"),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_ND96asr_v4")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.httpProxyConfig(Map.ofEntries(
Map.entry("httpProxy", "http://myproxy.server.com:8080"),
Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
Map.entry("noProxy",
"localhost",
"127.0.0.1"),
Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_node_public_ip=True,
gpu_instance_profile="MIG3g",
mode="System",
name="nodepool1",
os_type="Linux",
type="VirtualMachineScaleSets",
vm_size="Standard_ND96asr_v4",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=True,
enable_rbac=True,
http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
http_proxy="http://myproxy.server.com:8080",
https_proxy="https://myproxy.server.com:8080",
no_proxy=[
"localhost",
"127.0.0.1",
],
trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
),
kubernetes_version="",
linux_profile=azure_native.containerservice.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",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
HttpProxy: pulumi.String("http://myproxy.server.com:8080"),
HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
NoProxy: pulumi.StringArray{
pulumi.String("localhost"),
pulumi.String("127.0.0.1"),
},
TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
},
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.httpProxyConfig(Map.ofEntries(
Map.entry("httpProxy", "http://myproxy.server.com:8080"),
Map.entry("httpsProxy", "https://myproxy.server.com:8080"),
Map.entry("noProxy",
"localhost",
"127.0.0.1"),
Map.entry("trustedCa", "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=")
))
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_node_public_ip=True,
mode="System",
name="nodepool1",
os_type="Linux",
type="VirtualMachineScaleSets",
vm_size="Standard_DS2_v2",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=True,
enable_rbac=True,
http_proxy_config=azure_native.containerservice.ManagedClusterHTTPProxyConfigArgs(
http_proxy="http://myproxy.server.com:8080",
https_proxy="https://myproxy.server.com:8080",
no_proxy=[
"localhost",
"127.0.0.1",
],
trusted_ca="Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
),
kubernetes_version="",
linux_profile=azure_native.containerservice.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 LongTermSupport
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableEncryptionAtHost = true,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
ApiServerAccessProfile = new AzureNative.ContainerService.Inputs.ManagedClusterAPIServerAccessProfileArgs
{
DisableRunCommand = true,
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Base",
Tier = "Premium",
},
SupportPlan = "AKSLongTermSupport",
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableEncryptionAtHost: pulumi.Bool(true),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
ApiServerAccessProfile: &containerservice.ManagedClusterAPIServerAccessProfileArgs{
DisableRunCommand: pulumi.Bool(true),
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Base"),
Tier: pulumi.String("Premium"),
},
SupportPlan: pulumi.String("AKSLongTermSupport"),
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import 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.of("disableRunCommand", true))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.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", "Base"),
Map.entry("tier", "Premium")
))
.supportPlan("AKSLongTermSupport")
.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(
disable_run_command=True,
),
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
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="Base",
tier="Premium",
),
support_plan="AKSLongTermSupport",
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: {
disableRunCommand: true,
},
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: true,
enableRBAC: true,
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerProfile: {
managedOutboundIPs: {
count: 2,
},
},
loadBalancerSku: "standard",
outboundType: "loadBalancer",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Base",
tier: "Premium",
},
supportPlan: "AKSLongTermSupport",
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles: {}
agentPoolProfiles:
- count: 3
enableEncryptionAtHost: true
enableNodePublicIP: true
mode: System
name: nodepool1
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS2_v2
apiServerAccessProfile:
disableRunCommand: true
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: true
enableRBAC: true
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerProfile:
managedOutboundIPs:
count: 2
loadBalancerSku: standard
outboundType: loadBalancer
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Base
tier: Premium
supportPlan: AKSLongTermSupport
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
Create Managed Cluster with Node Public IP Prefix
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
NodePublicIPPrefixID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
NodePublicIPPrefixID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("nodePublicIPPrefixID", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_node_public_ip=True,
mode="System",
name="nodepool1",
node_public_ip_prefix_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix",
os_type="Linux",
type="VirtualMachineScaleSets",
vm_size="Standard_DS2_v2",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=True,
enable_rbac=True,
kubernetes_version="",
linux_profile=azure_native.containerservice.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 = "AzureLinux",
OsType = "Linux",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
HttpProxyConfig = new AzureNative.ContainerService.Inputs.ManagedClusterHTTPProxyConfigArgs
{
HttpProxy = "http://myproxy.server.com:8080",
HttpsProxy = "https://myproxy.server.com:8080",
NoProxy = new[]
{
"localhost",
"127.0.0.1",
},
TrustedCa = "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
},
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsSKU: pulumi.String("AzureLinux"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
HttpProxyConfig: &containerservice.ManagedClusterHTTPProxyConfigArgs{
HttpProxy: pulumi.String("http://myproxy.server.com:8080"),
HttpsProxy: pulumi.String("https://myproxy.server.com:8080"),
NoProxy: pulumi.StringArray{
pulumi.String("localhost"),
pulumi.String("127.0.0.1"),
},
TrustedCa: pulumi.String("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
},
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osSKU", "AzureLinux"),
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="AzureLinux",
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: "AzureLinux",
osType: "Linux",
type: "VirtualMachineScaleSets",
vmSize: "Standard_DS2_v2",
}],
autoScalerProfile: {
scaleDownDelayAfterAdd: "15m",
scanInterval: "20s",
},
diskEncryptionSetID: "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dnsPrefix: "dnsprefix1",
enablePodSecurityPolicy: true,
enableRBAC: true,
httpProxyConfig: {
httpProxy: "http://myproxy.server.com:8080",
httpsProxy: "https://myproxy.server.com:8080",
noProxy: [
"localhost",
"127.0.0.1",
],
trustedCa: "Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=",
},
kubernetesVersion: "",
linuxProfile: {
adminUsername: "azureuser",
ssh: {
publicKeys: [{
keyData: "keydata",
}],
},
},
location: "location1",
networkProfile: {
loadBalancerProfile: {
managedOutboundIPs: {
count: 2,
},
},
loadBalancerSku: "standard",
outboundType: "loadBalancer",
},
resourceGroupName: "rg1",
resourceName: "clustername1",
servicePrincipalProfile: {
clientId: "clientid",
secret: "secret",
},
sku: {
name: "Basic",
tier: "Free",
},
tags: {
archv2: "",
tier: "production",
},
windowsProfile: {
adminPassword: "replacePassword1234$",
adminUsername: "azureuser",
},
});
resources:
managedCluster:
type: azure-native:containerservice:ManagedCluster
properties:
addonProfiles: {}
agentPoolProfiles:
- count: 3
enableNodePublicIP: true
mode: System
name: nodepool1
osSKU: AzureLinux
osType: Linux
type: VirtualMachineScaleSets
vmSize: Standard_DS2_v2
autoScalerProfile:
scaleDownDelayAfterAdd: 15m
scanInterval: 20s
diskEncryptionSetID: /subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des
dnsPrefix: dnsprefix1
enablePodSecurityPolicy: true
enableRBAC: true
httpProxyConfig:
httpProxy: http://myproxy.server.com:8080
httpsProxy: https://myproxy.server.com:8080
noProxy:
- localhost
- 127.0.0.1
trustedCa: Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U=
kubernetesVersion:
linuxProfile:
adminUsername: azureuser
ssh:
publicKeys:
- keyData: keydata
location: location1
networkProfile:
loadBalancerProfile:
managedOutboundIPs:
count: 2
loadBalancerSku: standard
outboundType: loadBalancer
resourceGroupName: rg1
resourceName: clustername1
servicePrincipalProfile:
clientId: clientid
secret: secret
sku:
name: Basic
tier: Free
tags:
archv2:
tier: production
windowsProfile:
adminPassword: replacePassword1234$
adminUsername: azureuser
Create Managed Cluster with PPG
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var managedCluster = new AzureNative.ContainerService.ManagedCluster("managedCluster", new()
{
AddonProfiles = null,
AgentPoolProfiles = new[]
{
new AzureNative.ContainerService.Inputs.ManagedClusterAgentPoolProfileArgs
{
Count = 3,
EnableNodePublicIP = true,
Mode = "System",
Name = "nodepool1",
OsType = "Linux",
ProximityPlacementGroupID = "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
Type = "VirtualMachineScaleSets",
VmSize = "Standard_DS2_v2",
},
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DiskEncryptionSetID = "/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
ProximityPlacementGroupID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("proximityPlacementGroupID", "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_node_public_ip=True,
mode="System",
name="nodepool1",
os_type="Linux",
proximity_placement_group_id="/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1",
type="VirtualMachineScaleSets",
vm_size="Standard_DS2_v2",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=True,
enable_rbac=True,
kubernetes_version="",
linux_profile=azure_native.containerservice.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",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DiskEncryptionSetID: pulumi.String("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
PodIdentityProfile: &containerservice.ManagedClusterPodIdentityProfileArgs{
AllowNetworkPluginKubenet: pulumi.Bool(true),
Enabled: pulumi.Bool(true),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.diskEncryptionSetID("/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des")
.dnsPrefix("dnsprefix1")
.enablePodSecurityPolicy(true)
.enableRBAC(true)
.kubernetesVersion("")
.linuxProfile(Map.ofEntries(
Map.entry("adminUsername", "azureuser"),
Map.entry("ssh", Map.of("publicKeys", Map.of("keyData", "keydata")))
))
.location("location1")
.networkProfile(Map.ofEntries(
Map.entry("loadBalancerProfile", Map.of("managedOutboundIPs", Map.of("count", 2))),
Map.entry("loadBalancerSku", "standard"),
Map.entry("outboundType", "loadBalancer")
))
.podIdentityProfile(Map.ofEntries(
Map.entry("allowNetworkPluginKubenet", true),
Map.entry("enabled", true)
))
.resourceGroupName("rg1")
.resourceName("clustername1")
.servicePrincipalProfile(Map.ofEntries(
Map.entry("clientId", "clientid"),
Map.entry("secret", "secret")
))
.sku(Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Free")
))
.tags(Map.ofEntries(
Map.entry("archv2", ""),
Map.entry("tier", "production")
))
.windowsProfile(Map.ofEntries(
Map.entry("adminPassword", "replacePassword1234$"),
Map.entry("adminUsername", "azureuser")
))
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
managed_cluster = azure_native.containerservice.ManagedCluster("managedCluster",
addon_profiles={},
agent_pool_profiles=[azure_native.containerservice.ManagedClusterAgentPoolProfileArgs(
count=3,
enable_node_public_ip=True,
mode="System",
name="nodepool1",
os_type="Linux",
type="VirtualMachineScaleSets",
vm_size="Standard_DS2_v2",
)],
auto_scaler_profile=azure_native.containerservice.ManagedClusterPropertiesAutoScalerProfileArgs(
scale_down_delay_after_add="15m",
scan_interval="20s",
),
disk_encryption_set_id="/subscriptions/subid1/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des",
dns_prefix="dnsprefix1",
enable_pod_security_policy=True,
enable_rbac=True,
kubernetes_version="",
linux_profile=azure_native.containerservice.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 Cluster with RunCommand disabled
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
{
DisableRunCommand = true,
},
AutoScalerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterPropertiesAutoScalerProfileArgs
{
ScaleDownDelayAfterAdd = "15m",
ScanInterval = "20s",
},
DnsPrefix = "dnsprefix1",
EnablePodSecurityPolicy = true,
EnableRBAC = true,
KubernetesVersion = "",
LinuxProfile = new AzureNative.ContainerService.Inputs.ContainerServiceLinuxProfileArgs
{
AdminUsername = "azureuser",
Ssh = new AzureNative.ContainerService.Inputs.ContainerServiceSshConfigurationArgs
{
PublicKeys = new[]
{
new AzureNative.ContainerService.Inputs.ContainerServiceSshPublicKeyArgs
{
KeyData = "keydata",
},
},
},
},
Location = "location1",
NetworkProfile = new AzureNative.ContainerService.Inputs.ContainerServiceNetworkProfileArgs
{
LoadBalancerProfile = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileArgs
{
ManagedOutboundIPs = new AzureNative.ContainerService.Inputs.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs
{
Count = 2,
},
},
LoadBalancerSku = "standard",
OutboundType = "loadBalancer",
},
ResourceGroupName = "rg1",
ResourceName = "clustername1",
ServicePrincipalProfile = new AzureNative.ContainerService.Inputs.ManagedClusterServicePrincipalProfileArgs
{
ClientId = "clientid",
Secret = "secret",
},
Sku = new AzureNative.ContainerService.Inputs.ManagedClusterSKUArgs
{
Name = "Basic",
Tier = "Free",
},
Tags =
{
{ "archv2", "" },
{ "tier", "production" },
},
WindowsProfile = new AzureNative.ContainerService.Inputs.ManagedClusterWindowsProfileArgs
{
AdminPassword = "replacePassword1234$",
AdminUsername = "azureuser",
},
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/containerservice/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := containerservice.NewManagedCluster(ctx, "managedCluster", &containerservice.ManagedClusterArgs{
AddonProfiles: nil,
AgentPoolProfiles: []containerservice.ManagedClusterAgentPoolProfileArgs{
{
Count: pulumi.Int(3),
EnableEncryptionAtHost: pulumi.Bool(true),
EnableNodePublicIP: pulumi.Bool(true),
Mode: pulumi.String("System"),
Name: pulumi.String("nodepool1"),
OsType: pulumi.String("Linux"),
Type: pulumi.String("VirtualMachineScaleSets"),
VmSize: pulumi.String("Standard_DS2_v2"),
},
},
ApiServerAccessProfile: &containerservice.ManagedClusterAPIServerAccessProfileArgs{
DisableRunCommand: pulumi.Bool(true),
},
AutoScalerProfile: &containerservice.ManagedClusterPropertiesAutoScalerProfileArgs{
ScaleDownDelayAfterAdd: pulumi.String("15m"),
ScanInterval: pulumi.String("20s"),
},
DnsPrefix: pulumi.String("dnsprefix1"),
EnablePodSecurityPolicy: pulumi.Bool(true),
EnableRBAC: pulumi.Bool(true),
KubernetesVersion: pulumi.String(""),
LinuxProfile: containerservice.ContainerServiceLinuxProfileResponse{
AdminUsername: pulumi.String("azureuser"),
Ssh: interface{}{
PublicKeys: containerservice.ContainerServiceSshPublicKeyArray{
&containerservice.ContainerServiceSshPublicKeyArgs{
KeyData: pulumi.String("keydata"),
},
},
},
},
Location: pulumi.String("location1"),
NetworkProfile: containerservice.ContainerServiceNetworkProfileResponse{
LoadBalancerProfile: interface{}{
ManagedOutboundIPs: &containerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPsArgs{
Count: pulumi.Int(2),
},
},
LoadBalancerSku: pulumi.String("standard"),
OutboundType: pulumi.String("loadBalancer"),
},
ResourceGroupName: pulumi.String("rg1"),
ResourceName: pulumi.String("clustername1"),
ServicePrincipalProfile: &containerservice.ManagedClusterServicePrincipalProfileArgs{
ClientId: pulumi.String("clientid"),
Secret: pulumi.String("secret"),
},
Sku: &containerservice.ManagedClusterSKUArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Free"),
},
Tags: pulumi.StringMap{
"archv2": pulumi.String(""),
"tier": pulumi.String("production"),
},
WindowsProfile: &containerservice.ManagedClusterWindowsProfileArgs{
AdminPassword: pulumi.String("replacePassword1234$"),
AdminUsername: pulumi.String("azureuser"),
},
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.ManagedCluster;
import com.pulumi.azurenative.containerservice.ManagedClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var managedCluster = new ManagedCluster("managedCluster", ManagedClusterArgs.builder()
.addonProfiles()
.agentPoolProfiles(Map.ofEntries(
Map.entry("count", 3),
Map.entry("enableEncryptionAtHost", true),
Map.entry("enableNodePublicIP", true),
Map.entry("mode", "System"),
Map.entry("name", "nodepool1"),
Map.entry("osType", "Linux"),
Map.entry("type", "VirtualMachineScaleSets"),
Map.entry("vmSize", "Standard_DS2_v2")
))
.apiServerAccessProfile(Map.of("disableRunCommand", true))
.autoScalerProfile(Map.ofEntries(
Map.entry("scaleDownDelayAfterAdd", "15m"),
Map.entry("scanInterval", "20s")
))
.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",