Kubernetes
Manages a Node Pool within a Kubernetes Cluster
NOTE: Multiple Node Pools are only supported when the Kubernetes Cluster is using Virtual Machine Scale Sets.
Example Usage
This example provisions a basic Kubernetes Node Pool.
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
name: "example-resources",
location: "West Europe",
});
const exampleKubernetesCluster = new azure.containerservice.KubernetesCluster("example", {
name: "example-aks1",
location: example.location,
resourceGroupName: example.name,
dnsPrefix: "exampleaks1",
defaultNodePool: {
name: "default",
nodeCount: 1,
vmSize: "Standard_D2_v2",
},
servicePrincipal: {
clientId: "00000000-0000-0000-0000-000000000000",
clientSecret: "00000000000000000000000000000000",
},
});
const exampleKubernetesClusterNodePool = new azure.containerservice.KubernetesClusterNodePool("example", {
name: "internal",
kubernetesClusterId: exampleKubernetesCluster.id,
vmSize: "Standard_DS2_v2",
nodeCount: 1,
tags: {
Environment: "Production",
},
});import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
name="example-resources",
location="West Europe")
example_kubernetes_cluster = azure.containerservice.KubernetesCluster("example",
name="example-aks1",
location=example.location,
resource_group_name=example.name,
dns_prefix="exampleaks1",
default_node_pool=azure.containerservice.KubernetesClusterDefaultNodePoolArgs(
name="default",
node_count=1,
vm_size="Standard_D2_v2",
),
service_principal=azure.containerservice.KubernetesClusterServicePrincipalArgs(
client_id="00000000-0000-0000-0000-000000000000",
client_secret="00000000000000000000000000000000",
))
example_kubernetes_cluster_node_pool = azure.containerservice.KubernetesClusterNodePool("example",
name="internal",
kubernetes_cluster_id=example_kubernetes_cluster.id,
vm_size="Standard_DS2_v2",
node_count=1,
tags={
"Environment": "Production",
})using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
var example = new Azure.Core.ResourceGroup("example", new()
{
Name = "example-resources",
Location = "West Europe",
});
var exampleKubernetesCluster = new Azure.ContainerService.KubernetesCluster("example", new()
{
Name = "example-aks1",
Location = example.Location,
ResourceGroupName = example.Name,
DnsPrefix = "exampleaks1",
DefaultNodePool = new Azure.ContainerService.Inputs.KubernetesClusterDefaultNodePoolArgs
{
Name = "default",
NodeCount = 1,
VmSize = "Standard_D2_v2",
},
ServicePrincipal = new Azure.ContainerService.Inputs.KubernetesClusterServicePrincipalArgs
{
ClientId = "00000000-0000-0000-0000-000000000000",
ClientSecret = "00000000000000000000000000000000",
},
});
var exampleKubernetesClusterNodePool = new Azure.ContainerService.KubernetesClusterNodePool("example", new()
{
Name = "internal",
KubernetesClusterId = exampleKubernetesCluster.Id,
VmSize = "Standard_DS2_v2",
NodeCount = 1,
Tags =
{
{ "Environment", "Production" },
},
});
});package main
import (
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/containerservice"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
Name: pulumi.String("example-resources"),
Location: pulumi.String("West Europe"),
})
if err != nil {
return err
}
exampleKubernetesCluster, err := containerservice.NewKubernetesCluster(ctx, "example", &containerservice.KubernetesClusterArgs{
Name: pulumi.String("example-aks1"),
Location: example.Location,
ResourceGroupName: example.Name,
DnsPrefix: pulumi.String("exampleaks1"),
DefaultNodePool: &containerservice.KubernetesClusterDefaultNodePoolArgs{
Name: pulumi.String("default"),
NodeCount: pulumi.Int(1),
VmSize: pulumi.String("Standard_D2_v2"),
},
ServicePrincipal: &containerservice.KubernetesClusterServicePrincipalArgs{
ClientId: pulumi.String("00000000-0000-0000-0000-000000000000"),
ClientSecret: pulumi.String("00000000000000000000000000000000"),
},
})
if err != nil {
return err
}
_, err = containerservice.NewKubernetesClusterNodePool(ctx, "example", &containerservice.KubernetesClusterNodePoolArgs{
Name: pulumi.String("internal"),
KubernetesClusterId: exampleKubernetesCluster.ID(),
VmSize: pulumi.String("Standard_DS2_v2"),
NodeCount: pulumi.Int(1),
Tags: pulumi.StringMap{
"Environment": pulumi.String("Production"),
},
})
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.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.containerservice.KubernetesCluster;
import com.pulumi.azure.containerservice.KubernetesClusterArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterDefaultNodePoolArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterServicePrincipalArgs;
import com.pulumi.azure.containerservice.KubernetesClusterNodePool;
import com.pulumi.azure.containerservice.KubernetesClusterNodePoolArgs;
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 example = new ResourceGroup("example", ResourceGroupArgs.builder()
.name("example-resources")
.location("West Europe")
.build());
var exampleKubernetesCluster = new KubernetesCluster("exampleKubernetesCluster", KubernetesClusterArgs.builder()
.name("example-aks1")
.location(example.location())
.resourceGroupName(example.name())
.dnsPrefix("exampleaks1")
.defaultNodePool(KubernetesClusterDefaultNodePoolArgs.builder()
.name("default")
.nodeCount(1)
.vmSize("Standard_D2_v2")
.build())
.servicePrincipal(KubernetesClusterServicePrincipalArgs.builder()
.clientId("00000000-0000-0000-0000-000000000000")
.clientSecret("00000000000000000000000000000000")
.build())
.build());
var exampleKubernetesClusterNodePool = new KubernetesClusterNodePool("exampleKubernetesClusterNodePool", KubernetesClusterNodePoolArgs.builder()
.name("internal")
.kubernetesClusterId(exampleKubernetesCluster.id())
.vmSize("Standard_DS2_v2")
.nodeCount(1)
.tags(Map.of("Environment", "Production"))
.build());
}
}resources:
example:
type: azure:core:ResourceGroup
properties:
name: example-resources
location: West Europe
exampleKubernetesCluster:
type: azure:containerservice:KubernetesCluster
name: example
properties:
name: example-aks1
location: ${example.location}
resourceGroupName: ${example.name}
dnsPrefix: exampleaks1
defaultNodePool:
name: default
nodeCount: 1
vmSize: Standard_D2_v2
servicePrincipal:
clientId: 00000000-0000-0000-0000-000000000000
clientSecret: '00000000000000000000000000000000'
exampleKubernetesClusterNodePool:
type: azure:containerservice:KubernetesClusterNodePool
name: example
properties:
name: internal
kubernetesClusterId: ${exampleKubernetesCluster.id}
vmSize: Standard_DS2_v2
nodeCount: 1
tags:
Environment: ProductionImport
Kubernetes Cluster Node Pools can be imported using the resource id, e.g.
$ pulumi import azure:containerservice/kubernetesClusterNodePool:KubernetesClusterNodePool pool1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool1Constructors
Properties
Specifies the ID of the Capacity Reservation Group where this Node Pool should exist. Changing this forces a new resource to be created.
Specifies whether to trust a Custom CA.
Whether to enable auto-scaler.
Should the nodes in this Node Pool have host encryption enabled? Changing this forces a new resource to be created.
Should each node have a Public IP Address? Changing this forces a new resource to be created.
The Eviction Policy which should be used for Virtual Machines within the Virtual Machine Scale Set powering this Node Pool. Possible values are Deallocate and Delete. Changing this forces a new resource to be created.
Should the nodes in this Node Pool have Federal Information Processing Standard enabled? Changing this forces a new resource to be created.
Specifies the GPU MIG instance profile for supported GPU VM SKU. The allowed values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g. Changing this forces a new resource to be created.
The fully qualified resource ID of the Dedicated Host Group to provision virtual machines from. Changing this forces a new resource to be created.
A kubelet_config block as defined below. Changing this forces a new resource to be created.
The type of disk used by kubelet. Possible values are OS and Temporary.
The ID of the Kubernetes Cluster where this Node Pool should exist. Changing this forces a new resource to be created.
A linux_os_config block as defined below. Changing this forces a new resource to be created.
A base64-encoded string which will be written to /etc/motd after decoding. This allows customization of the message of the day for Linux nodes. It cannot be specified for Windows nodes and must be a static string (i.e. will be printed raw and not executed as a script). Changing this forces a new resource to be created.
A map of Kubernetes labels which should be applied to nodes in this Node Pool.
A node_network_profile block as documented below.
Resource ID for the Public IP Addresses Prefix for the nodes in this Node Pool. enable_node_public_ip should be true. Changing this forces a new resource to be created.
A list of Kubernetes taints which should be applied to nodes in the agent pool (e.g key=value:NoSchedule).
Version of Kubernetes used for the Agents. If not specified, the latest recommended version will be used at provisioning time (but won't auto-upgrade). AKS does not require an exact patch version to be specified, minor version aliases such as 1.22 are also supported. - The minor version's latest GA patch is automatically chosen in that case. More details can be found in the documentation.
The Agent Operating System disk size in GB. Changing this forces a new resource to be created.
The type of disk which should be used for the Operating System. Possible values are Ephemeral and Managed. Defaults to Managed. Changing this forces a new resource to be created.
Specifies the OS SKU used by the agent pool. Possible values are AzureLinux, Ubuntu, Windows2019 and Windows2022. If not specified, the default is Ubuntu if OSType=Linux or Windows2019 if OSType=Windows. And the default Windows OSSKU will be changed to Windows2022 after Windows2019 is deprecated. Changing this forces a new resource to be created.
The ID of the Subnet where the pods in the Node Pool should exist. Changing this forces a new resource to be created.
The ID of the Proximity Placement Group where the Virtual Machine Scale Set that powers this Node Pool will be placed. Changing this forces a new resource to be created.
Specifies how the node pool should deal with scaled-down nodes. Allowed values are Delete and Deallocate. Defaults to Delete.
The ID of the Snapshot which should be used to create this Node Pool. Changing this forces a new resource to be created.
The maximum price you're willing to pay in USD per Virtual Machine. Valid values are -1 (the current on-demand price for a Virtual Machine) or a positive value with up to five decimal places. Changing this forces a new resource to be created.
Used to specify whether the UltraSSD is enabled in the Node Pool. Defaults to false. See the documentation for more information. Changing this forces a new resource to be created.
A upgrade_settings block as documented below.
The ID of the Subnet where this Node Pool should exist. Changing this forces a new resource to be created.
A windows_profile block as documented below. Changing this forces a new resource to be created.
Used to specify the workload runtime. Allowed values are OCIContainer, WasmWasi and KataMshvVmIsolation.