Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Castai Provider
  3. API Docs
  4. NodeTemplate
castai 7.44.0 published on Friday, Mar 21, 2025 by castai
castai/terraform-provider-castai

castai.NodeTemplate

Explore with Pulumi AI

castai logo
castai 7.44.0 published on Friday, Mar 21, 2025 by castai
castai/terraform-provider-castai

    CAST AI node template resource to manage node templates

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as castai from "@pulumi/castai";

const defaultByCastai = new castai.NodeTemplate("defaultByCastai", {
    clusterId: castai_eks_cluster.test.id,
    isDefault: true,
    isEnabled: true,
    configurationId: castai_node_configuration["default"].id,
    shouldTaint: true,
    customLabels: {
        env: "production",
    },
    customTaints: [{
        key: "dedicated",
        value: "backend",
        effect: "NoSchedule",
    }],
    constraints: {
        onDemand: true,
        spot: false,
        useSpotFallbacks: true,
        fallbackRestoreRateSeconds: 300,
        enableSpotDiversity: true,
        spotDiversityPriceIncreaseLimitPercent: 20,
        spotInterruptionPredictionsEnabled: true,
        spotInterruptionPredictionsType: "aws-rebalance-recommendations",
        computeOptimizedState: "disabled",
        storageOptimizedState: "disabled",
        isGpuOnly: false,
        minCpu: 2,
        maxCpu: 8,
        minMemory: 4096,
        maxMemory: 16384,
        architectures: ["amd64"],
        azs: [
            "us-east-2a",
            "us-east-2b",
        ],
        burstableInstances: "disabled",
        customerSpecific: "disabled",
        instanceFamilies: {
            includes: ["c5"],
        },
        customPriorities: [{
            instanceFamilies: ["c5"],
            spot: false,
            onDemand: true,
        }],
    },
});

    import pulumi
import pulumi_castai as castai

default_by_castai = castai.NodeTemplate("defaultByCastai",
    cluster_id=castai_eks_cluster["test"]["id"],
    is_default=True,
    is_enabled=True,
    configuration_id=castai_node_configuration["default"]["id"],
    should_taint=True,
    custom_labels={
        "env": "production",
    },
    custom_taints=[{
        "key": "dedicated",
        "value": "backend",
        "effect": "NoSchedule",
    }],
    constraints={
        "on_demand": True,
        "spot": False,
        "use_spot_fallbacks": True,
        "fallback_restore_rate_seconds": 300,
        "enable_spot_diversity": True,
        "spot_diversity_price_increase_limit_percent": 20,
        "spot_interruption_predictions_enabled": True,
        "spot_interruption_predictions_type": "aws-rebalance-recommendations",
        "compute_optimized_state": "disabled",
        "storage_optimized_state": "disabled",
        "is_gpu_only": False,
        "min_cpu": 2,
        "max_cpu": 8,
        "min_memory": 4096,
        "max_memory": 16384,
        "architectures": ["amd64"],
        "azs": [
            "us-east-2a",
            "us-east-2b",
        ],
        "burstable_instances": "disabled",
        "customer_specific": "disabled",
        "instance_families": {
            "includes": ["c5"],
        },
        "custom_priorities": [{
            "instance_families": ["c5"],
            "spot": False,
            "on_demand": True,
        }],
    })

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/castai/v7/castai"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := castai.NewNodeTemplate(ctx, "defaultByCastai", &castai.NodeTemplateArgs{
			ClusterId:       pulumi.Any(castai_eks_cluster.Test.Id),
			IsDefault:       pulumi.Bool(true),
			IsEnabled:       pulumi.Bool(true),
			ConfigurationId: pulumi.Any(castai_node_configuration.Default.Id),
			ShouldTaint:     pulumi.Bool(true),
			CustomLabels: pulumi.StringMap{
				"env": pulumi.String("production"),
			},
			CustomTaints: castai.NodeTemplateCustomTaintArray{
				&castai.NodeTemplateCustomTaintArgs{
					Key:    pulumi.String("dedicated"),
					Value:  pulumi.String("backend"),
					Effect: pulumi.String("NoSchedule"),
				},
			},
			Constraints: &castai.NodeTemplateConstraintsArgs{
				OnDemand:                               pulumi.Bool(true),
				Spot:                                   pulumi.Bool(false),
				UseSpotFallbacks:                       pulumi.Bool(true),
				FallbackRestoreRateSeconds:             pulumi.Float64(300),
				EnableSpotDiversity:                    pulumi.Bool(true),
				SpotDiversityPriceIncreaseLimitPercent: pulumi.Float64(20),
				SpotInterruptionPredictionsEnabled:     pulumi.Bool(true),
				SpotInterruptionPredictionsType:        pulumi.String("aws-rebalance-recommendations"),
				ComputeOptimizedState:                  pulumi.String("disabled"),
				StorageOptimizedState:                  pulumi.String("disabled"),
				IsGpuOnly:                              pulumi.Bool(false),
				MinCpu:                                 pulumi.Float64(2),
				MaxCpu:                                 pulumi.Float64(8),
				MinMemory:                              pulumi.Float64(4096),
				MaxMemory:                              pulumi.Float64(16384),
				Architectures: pulumi.StringArray{
					pulumi.String("amd64"),
				},
				Azs: pulumi.StringArray{
					pulumi.String("us-east-2a"),
					pulumi.String("us-east-2b"),
				},
				BurstableInstances: pulumi.String("disabled"),
				CustomerSpecific:   pulumi.String("disabled"),
				InstanceFamilies: &castai.NodeTemplateConstraintsInstanceFamiliesArgs{
					Includes: pulumi.StringArray{
						pulumi.String("c5"),
					},
				},
				CustomPriorities: castai.NodeTemplateConstraintsCustomPriorityArray{
					&castai.NodeTemplateConstraintsCustomPriorityArgs{
						InstanceFamilies: pulumi.StringArray{
							pulumi.String("c5"),
						},
						Spot:     pulumi.Bool(false),
						OnDemand: pulumi.Bool(true),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var defaultByCastai = new Castai.NodeTemplate("defaultByCastai", new()
    {
        ClusterId = castai_eks_cluster.Test.Id,
        IsDefault = true,
        IsEnabled = true,
        ConfigurationId = castai_node_configuration.Default.Id,
        ShouldTaint = true,
        CustomLabels = 
        {
            { "env", "production" },
        },
        CustomTaints = new[]
        {
            new Castai.Inputs.NodeTemplateCustomTaintArgs
            {
                Key = "dedicated",
                Value = "backend",
                Effect = "NoSchedule",
            },
        },
        Constraints = new Castai.Inputs.NodeTemplateConstraintsArgs
        {
            OnDemand = true,
            Spot = false,
            UseSpotFallbacks = true,
            FallbackRestoreRateSeconds = 300,
            EnableSpotDiversity = true,
            SpotDiversityPriceIncreaseLimitPercent = 20,
            SpotInterruptionPredictionsEnabled = true,
            SpotInterruptionPredictionsType = "aws-rebalance-recommendations",
            ComputeOptimizedState = "disabled",
            StorageOptimizedState = "disabled",
            IsGpuOnly = false,
            MinCpu = 2,
            MaxCpu = 8,
            MinMemory = 4096,
            MaxMemory = 16384,
            Architectures = new[]
            {
                "amd64",
            },
            Azs = new[]
            {
                "us-east-2a",
                "us-east-2b",
            },
            BurstableInstances = "disabled",
            CustomerSpecific = "disabled",
            InstanceFamilies = new Castai.Inputs.NodeTemplateConstraintsInstanceFamiliesArgs
            {
                Includes = new[]
                {
                    "c5",
                },
            },
            CustomPriorities = new[]
            {
                new Castai.Inputs.NodeTemplateConstraintsCustomPriorityArgs
                {
                    InstanceFamilies = new[]
                    {
                        "c5",
                    },
                    Spot = false,
                    OnDemand = true,
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.castai.NodeTemplate;
import com.pulumi.castai.NodeTemplateArgs;
import com.pulumi.castai.inputs.NodeTemplateCustomTaintArgs;
import com.pulumi.castai.inputs.NodeTemplateConstraintsArgs;
import com.pulumi.castai.inputs.NodeTemplateConstraintsInstanceFamiliesArgs;
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 defaultByCastai = new NodeTemplate("defaultByCastai", NodeTemplateArgs.builder()
            .clusterId(castai_eks_cluster.test().id())
            .isDefault(true)
            .isEnabled(true)
            .configurationId(castai_node_configuration.default().id())
            .shouldTaint(true)
            .customLabels(Map.of("env", "production"))
            .customTaints(NodeTemplateCustomTaintArgs.builder()
                .key("dedicated")
                .value("backend")
                .effect("NoSchedule")
                .build())
            .constraints(NodeTemplateConstraintsArgs.builder()
                .onDemand(true)
                .spot(false)
                .useSpotFallbacks(true)
                .fallbackRestoreRateSeconds(300)
                .enableSpotDiversity(true)
                .spotDiversityPriceIncreaseLimitPercent(20)
                .spotInterruptionPredictionsEnabled(true)
                .spotInterruptionPredictionsType("aws-rebalance-recommendations")
                .computeOptimizedState("disabled")
                .storageOptimizedState("disabled")
                .isGpuOnly(false)
                .minCpu(2)
                .maxCpu(8)
                .minMemory(4096)
                .maxMemory(16384)
                .architectures("amd64")
                .azs(                
                    "us-east-2a",
                    "us-east-2b")
                .burstableInstances("disabled")
                .customerSpecific("disabled")
                .instanceFamilies(NodeTemplateConstraintsInstanceFamiliesArgs.builder()
                    .includes("c5")
                    .build())
                .customPriorities(NodeTemplateConstraintsCustomPriorityArgs.builder()
                    .instanceFamilies("c5")
                    .spot(false)
                    .onDemand(true)
                    .build())
                .build())
            .build());

    }
}

    resources:
  defaultByCastai:
    type: castai:NodeTemplate
    properties:
      clusterId: ${castai_eks_cluster.test.id}
      isDefault: true
      isEnabled: true
      configurationId: ${castai_node_configuration.default.id}
      shouldTaint: true
      customLabels:
        env: production
      customTaints:
        - key: dedicated
          value: backend
          effect: NoSchedule
      constraints:
        onDemand: true
        spot: false
        useSpotFallbacks: true
        fallbackRestoreRateSeconds: 300
        enableSpotDiversity: true
        spotDiversityPriceIncreaseLimitPercent: 20
        spotInterruptionPredictionsEnabled: true
        spotInterruptionPredictionsType: aws-rebalance-recommendations
        computeOptimizedState: disabled
        storageOptimizedState: disabled
        isGpuOnly: false
        minCpu: 2
        maxCpu: 8
        minMemory: 4096
        maxMemory: 16384
        architectures:
          - amd64
        azs:
          - us-east-2a
          - us-east-2b
        burstableInstances: disabled
        customerSpecific: disabled
        instanceFamilies:
          includes:
            - c5
        customPriorities:
          - instanceFamilies:
              - c5
            spot: false
            onDemand: true

    Create NodeTemplate Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new NodeTemplate(name: string, args?: NodeTemplateArgs, opts?: CustomResourceOptions);
    @overload
def NodeTemplate(resource_name: str,
                 args: Optional[NodeTemplateArgs] = None,
                 opts: Optional[ResourceOptions] = None)

@overload
def NodeTemplate(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 cluster_id: Optional[str] = None,
                 configuration_id: Optional[str] = None,
                 constraints: Optional[NodeTemplateConstraintsArgs] = None,
                 custom_instances_enabled: Optional[bool] = None,
                 custom_instances_with_extended_memory_enabled: Optional[bool] = None,
                 custom_labels: Optional[Mapping[str, str]] = None,
                 custom_taints: Optional[Sequence[NodeTemplateCustomTaintArgs]] = None,
                 is_default: Optional[bool] = None,
                 is_enabled: Optional[bool] = None,
                 name: Optional[str] = None,
                 node_template_id: Optional[str] = None,
                 rebalancing_config_min_nodes: Optional[float] = None,
                 should_taint: Optional[bool] = None,
                 timeouts: Optional[NodeTemplateTimeoutsArgs] = None)
    func NewNodeTemplate(ctx *Context, name string, args *NodeTemplateArgs, opts ...ResourceOption) (*NodeTemplate, error)
    public NodeTemplate(string name, NodeTemplateArgs? args = null, CustomResourceOptions? opts = null)
    public NodeTemplate(String name, NodeTemplateArgs args)
public NodeTemplate(String name, NodeTemplateArgs args, CustomResourceOptions options)

    type: castai:NodeTemplate
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args NodeTemplateArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args NodeTemplateArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args NodeTemplateArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args NodeTemplateArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args NodeTemplateArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var nodeTemplateResource = new Castai.NodeTemplate("nodeTemplateResource", new()
{
    ClusterId = "string",
    ConfigurationId = "string",
    Constraints = new Castai.Inputs.NodeTemplateConstraintsArgs
    {
        ArchitecturePriorities = new[]
        {
            "string",
        },
        Architectures = new[]
        {
            "string",
        },
        Azs = new[]
        {
            "string",
        },
        BurstableInstances = "string",
        ComputeOptimized = false,
        ComputeOptimizedState = "string",
        CpuManufacturers = new[]
        {
            "string",
        },
        CustomPriorities = new[]
        {
            new Castai.Inputs.NodeTemplateConstraintsCustomPriorityArgs
            {
                InstanceFamilies = new[]
                {
                    "string",
                },
                OnDemand = false,
                Spot = false,
            },
        },
        CustomerSpecific = "string",
        DedicatedNodeAffinities = new[]
        {
            new Castai.Inputs.NodeTemplateConstraintsDedicatedNodeAffinityArgs
            {
                AzName = "string",
                InstanceTypes = new[]
                {
                    "string",
                },
                Name = "string",
                Affinities = new[]
                {
                    new Castai.Inputs.NodeTemplateConstraintsDedicatedNodeAffinityAffinityArgs
                    {
                        Key = "string",
                        Operator = "string",
                        Values = new[]
                        {
                            "string",
                        },
                    },
                },
            },
        },
        EnableSpotDiversity = false,
        FallbackRestoreRateSeconds = 0,
        Gpu = new Castai.Inputs.NodeTemplateConstraintsGpuArgs
        {
            ExcludeNames = new[]
            {
                "string",
            },
            IncludeNames = new[]
            {
                "string",
            },
            Manufacturers = new[]
            {
                "string",
            },
            MaxCount = 0,
            MinCount = 0,
        },
        InstanceFamilies = new Castai.Inputs.NodeTemplateConstraintsInstanceFamiliesArgs
        {
            Excludes = new[]
            {
                "string",
            },
            Includes = new[]
            {
                "string",
            },
        },
        IsGpuOnly = false,
        MaxCpu = 0,
        MaxMemory = 0,
        MinCpu = 0,
        MinMemory = 0,
        OnDemand = false,
        Os = new[]
        {
            "string",
        },
        ResourceLimits = new Castai.Inputs.NodeTemplateConstraintsResourceLimitsArgs
        {
            CpuLimitEnabled = false,
            CpuLimitMaxCores = 0,
        },
        Spot = false,
        SpotDiversityPriceIncreaseLimitPercent = 0,
        SpotInterruptionPredictionsEnabled = false,
        SpotInterruptionPredictionsType = "string",
        StorageOptimized = false,
        StorageOptimizedState = "string",
        UseSpotFallbacks = false,
    },
    CustomInstancesEnabled = false,
    CustomInstancesWithExtendedMemoryEnabled = false,
    CustomLabels = 
    {
        { "string", "string" },
    },
    CustomTaints = new[]
    {
        new Castai.Inputs.NodeTemplateCustomTaintArgs
        {
            Key = "string",
            Effect = "string",
            Value = "string",
        },
    },
    IsDefault = false,
    IsEnabled = false,
    Name = "string",
    NodeTemplateId = "string",
    RebalancingConfigMinNodes = 0,
    ShouldTaint = false,
    Timeouts = new Castai.Inputs.NodeTemplateTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
        Read = "string",
        Update = "string",
    },
});

    example, err := castai.NewNodeTemplate(ctx, "nodeTemplateResource", &castai.NodeTemplateArgs{
ClusterId: pulumi.String("string"),
ConfigurationId: pulumi.String("string"),
Constraints: &.NodeTemplateConstraintsArgs{
ArchitecturePriorities: pulumi.StringArray{
pulumi.String("string"),
},
Architectures: pulumi.StringArray{
pulumi.String("string"),
},
Azs: pulumi.StringArray{
pulumi.String("string"),
},
BurstableInstances: pulumi.String("string"),
ComputeOptimized: pulumi.Bool(false),
ComputeOptimizedState: pulumi.String("string"),
CpuManufacturers: pulumi.StringArray{
pulumi.String("string"),
},
CustomPriorities: .NodeTemplateConstraintsCustomPriorityArray{
&.NodeTemplateConstraintsCustomPriorityArgs{
InstanceFamilies: pulumi.StringArray{
pulumi.String("string"),
},
OnDemand: pulumi.Bool(false),
Spot: pulumi.Bool(false),
},
},
CustomerSpecific: pulumi.String("string"),
DedicatedNodeAffinities: .NodeTemplateConstraintsDedicatedNodeAffinityArray{
&.NodeTemplateConstraintsDedicatedNodeAffinityArgs{
AzName: pulumi.String("string"),
InstanceTypes: pulumi.StringArray{
pulumi.String("string"),
},
Name: pulumi.String("string"),
Affinities: .NodeTemplateConstraintsDedicatedNodeAffinityAffinityArray{
&.NodeTemplateConstraintsDedicatedNodeAffinityAffinityArgs{
Key: pulumi.String("string"),
Operator: pulumi.String("string"),
Values: pulumi.StringArray{
pulumi.String("string"),
},
},
},
},
},
EnableSpotDiversity: pulumi.Bool(false),
FallbackRestoreRateSeconds: pulumi.Float64(0),
Gpu: &.NodeTemplateConstraintsGpuArgs{
ExcludeNames: pulumi.StringArray{
pulumi.String("string"),
},
IncludeNames: pulumi.StringArray{
pulumi.String("string"),
},
Manufacturers: pulumi.StringArray{
pulumi.String("string"),
},
MaxCount: pulumi.Float64(0),
MinCount: pulumi.Float64(0),
},
InstanceFamilies: &.NodeTemplateConstraintsInstanceFamiliesArgs{
Excludes: pulumi.StringArray{
pulumi.String("string"),
},
Includes: pulumi.StringArray{
pulumi.String("string"),
},
},
IsGpuOnly: pulumi.Bool(false),
MaxCpu: pulumi.Float64(0),
MaxMemory: pulumi.Float64(0),
MinCpu: pulumi.Float64(0),
MinMemory: pulumi.Float64(0),
OnDemand: pulumi.Bool(false),
Os: pulumi.StringArray{
pulumi.String("string"),
},
ResourceLimits: &.NodeTemplateConstraintsResourceLimitsArgs{
CpuLimitEnabled: pulumi.Bool(false),
CpuLimitMaxCores: pulumi.Float64(0),
},
Spot: pulumi.Bool(false),
SpotDiversityPriceIncreaseLimitPercent: pulumi.Float64(0),
SpotInterruptionPredictionsEnabled: pulumi.Bool(false),
SpotInterruptionPredictionsType: pulumi.String("string"),
StorageOptimized: pulumi.Bool(false),
StorageOptimizedState: pulumi.String("string"),
UseSpotFallbacks: pulumi.Bool(false),
},
CustomInstancesEnabled: pulumi.Bool(false),
CustomInstancesWithExtendedMemoryEnabled: pulumi.Bool(false),
CustomLabels: pulumi.StringMap{
"string": pulumi.String("string"),
},
CustomTaints: .NodeTemplateCustomTaintArray{
&.NodeTemplateCustomTaintArgs{
Key: pulumi.String("string"),
Effect: pulumi.String("string"),
Value: pulumi.String("string"),
},
},
IsDefault: pulumi.Bool(false),
IsEnabled: pulumi.Bool(false),
Name: pulumi.String("string"),
NodeTemplateId: pulumi.String("string"),
RebalancingConfigMinNodes: pulumi.Float64(0),
ShouldTaint: pulumi.Bool(false),
Timeouts: &.NodeTemplateTimeoutsArgs{
Create: pulumi.String("string"),
Delete: pulumi.String("string"),
Read: pulumi.String("string"),
Update: pulumi.String("string"),
},
})

    var nodeTemplateResource = new NodeTemplate("nodeTemplateResource", NodeTemplateArgs.builder()
    .clusterId("string")
    .configurationId("string")
    .constraints(NodeTemplateConstraintsArgs.builder()
        .architecturePriorities("string")
        .architectures("string")
        .azs("string")
        .burstableInstances("string")
        .computeOptimized(false)
        .computeOptimizedState("string")
        .cpuManufacturers("string")
        .customPriorities(NodeTemplateConstraintsCustomPriorityArgs.builder()
            .instanceFamilies("string")
            .onDemand(false)
            .spot(false)
            .build())
        .customerSpecific("string")
        .dedicatedNodeAffinities(NodeTemplateConstraintsDedicatedNodeAffinityArgs.builder()
            .azName("string")
            .instanceTypes("string")
            .name("string")
            .affinities(NodeTemplateConstraintsDedicatedNodeAffinityAffinityArgs.builder()
                .key("string")
                .operator("string")
                .values("string")
                .build())
            .build())
        .enableSpotDiversity(false)
        .fallbackRestoreRateSeconds(0)
        .gpu(NodeTemplateConstraintsGpuArgs.builder()
            .excludeNames("string")
            .includeNames("string")
            .manufacturers("string")
            .maxCount(0)
            .minCount(0)
            .build())
        .instanceFamilies(NodeTemplateConstraintsInstanceFamiliesArgs.builder()
            .excludes("string")
            .includes("string")
            .build())
        .isGpuOnly(false)
        .maxCpu(0)
        .maxMemory(0)
        .minCpu(0)
        .minMemory(0)
        .onDemand(false)
        .os("string")
        .resourceLimits(NodeTemplateConstraintsResourceLimitsArgs.builder()
            .cpuLimitEnabled(false)
            .cpuLimitMaxCores(0)
            .build())
        .spot(false)
        .spotDiversityPriceIncreaseLimitPercent(0)
        .spotInterruptionPredictionsEnabled(false)
        .spotInterruptionPredictionsType("string")
        .storageOptimized(false)
        .storageOptimizedState("string")
        .useSpotFallbacks(false)
        .build())
    .customInstancesEnabled(false)
    .customInstancesWithExtendedMemoryEnabled(false)
    .customLabels(Map.of("string", "string"))
    .customTaints(NodeTemplateCustomTaintArgs.builder()
        .key("string")
        .effect("string")
        .value("string")
        .build())
    .isDefault(false)
    .isEnabled(false)
    .name("string")
    .nodeTemplateId("string")
    .rebalancingConfigMinNodes(0)
    .shouldTaint(false)
    .timeouts(NodeTemplateTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .read("string")
        .update("string")
        .build())
    .build());

    node_template_resource = castai.NodeTemplate("nodeTemplateResource",
    cluster_id="string",
    configuration_id="string",
    constraints={
        "architecture_priorities": ["string"],
        "architectures": ["string"],
        "azs": ["string"],
        "burstable_instances": "string",
        "compute_optimized": False,
        "compute_optimized_state": "string",
        "cpu_manufacturers": ["string"],
        "custom_priorities": [{
            "instance_families": ["string"],
            "on_demand": False,
            "spot": False,
        }],
        "customer_specific": "string",
        "dedicated_node_affinities": [{
            "az_name": "string",
            "instance_types": ["string"],
            "name": "string",
            "affinities": [{
                "key": "string",
                "operator": "string",
                "values": ["string"],
            }],
        }],
        "enable_spot_diversity": False,
        "fallback_restore_rate_seconds": 0,
        "gpu": {
            "exclude_names": ["string"],
            "include_names": ["string"],
            "manufacturers": ["string"],
            "max_count": 0,
            "min_count": 0,
        },
        "instance_families": {
            "excludes": ["string"],
            "includes": ["string"],
        },
        "is_gpu_only": False,
        "max_cpu": 0,
        "max_memory": 0,
        "min_cpu": 0,
        "min_memory": 0,
        "on_demand": False,
        "os": ["string"],
        "resource_limits": {
            "cpu_limit_enabled": False,
            "cpu_limit_max_cores": 0,
        },
        "spot": False,
        "spot_diversity_price_increase_limit_percent": 0,
        "spot_interruption_predictions_enabled": False,
        "spot_interruption_predictions_type": "string",
        "storage_optimized": False,
        "storage_optimized_state": "string",
        "use_spot_fallbacks": False,
    },
    custom_instances_enabled=False,
    custom_instances_with_extended_memory_enabled=False,
    custom_labels={
        "string": "string",
    },
    custom_taints=[{
        "key": "string",
        "effect": "string",
        "value": "string",
    }],
    is_default=False,
    is_enabled=False,
    name="string",
    node_template_id="string",
    rebalancing_config_min_nodes=0,
    should_taint=False,
    timeouts={
        "create": "string",
        "delete": "string",
        "read": "string",
        "update": "string",
    })

    const nodeTemplateResource = new castai.NodeTemplate("nodeTemplateResource", {
    clusterId: "string",
    configurationId: "string",
    constraints: {
        architecturePriorities: ["string"],
        architectures: ["string"],
        azs: ["string"],
        burstableInstances: "string",
        computeOptimized: false,
        computeOptimizedState: "string",
        cpuManufacturers: ["string"],
        customPriorities: [{
            instanceFamilies: ["string"],
            onDemand: false,
            spot: false,
        }],
        customerSpecific: "string",
        dedicatedNodeAffinities: [{
            azName: "string",
            instanceTypes: ["string"],
            name: "string",
            affinities: [{
                key: "string",
                operator: "string",
                values: ["string"],
            }],
        }],
        enableSpotDiversity: false,
        fallbackRestoreRateSeconds: 0,
        gpu: {
            excludeNames: ["string"],
            includeNames: ["string"],
            manufacturers: ["string"],
            maxCount: 0,
            minCount: 0,
        },
        instanceFamilies: {
            excludes: ["string"],
            includes: ["string"],
        },
        isGpuOnly: false,
        maxCpu: 0,
        maxMemory: 0,
        minCpu: 0,
        minMemory: 0,
        onDemand: false,
        os: ["string"],
        resourceLimits: {
            cpuLimitEnabled: false,
            cpuLimitMaxCores: 0,
        },
        spot: false,
        spotDiversityPriceIncreaseLimitPercent: 0,
        spotInterruptionPredictionsEnabled: false,
        spotInterruptionPredictionsType: "string",
        storageOptimized: false,
        storageOptimizedState: "string",
        useSpotFallbacks: false,
    },
    customInstancesEnabled: false,
    customInstancesWithExtendedMemoryEnabled: false,
    customLabels: {
        string: "string",
    },
    customTaints: [{
        key: "string",
        effect: "string",
        value: "string",
    }],
    isDefault: false,
    isEnabled: false,
    name: "string",
    nodeTemplateId: "string",
    rebalancingConfigMinNodes: 0,
    shouldTaint: false,
    timeouts: {
        create: "string",
        "delete": "string",
        read: "string",
        update: "string",
    },
});

    type: castai:NodeTemplate
properties:
    clusterId: string
    configurationId: string
    constraints:
        architecturePriorities:
            - string
        architectures:
            - string
        azs:
            - string
        burstableInstances: string
        computeOptimized: false
        computeOptimizedState: string
        cpuManufacturers:
            - string
        customPriorities:
            - instanceFamilies:
                - string
              onDemand: false
              spot: false
        customerSpecific: string
        dedicatedNodeAffinities:
            - affinities:
                - key: string
                  operator: string
                  values:
                    - string
              azName: string
              instanceTypes:
                - string
              name: string
        enableSpotDiversity: false
        fallbackRestoreRateSeconds: 0
        gpu:
            excludeNames:
                - string
            includeNames:
                - string
            manufacturers:
                - string
            maxCount: 0
            minCount: 0
        instanceFamilies:
            excludes:
                - string
            includes:
                - string
        isGpuOnly: false
        maxCpu: 0
        maxMemory: 0
        minCpu: 0
        minMemory: 0
        onDemand: false
        os:
            - string
        resourceLimits:
            cpuLimitEnabled: false
            cpuLimitMaxCores: 0
        spot: false
        spotDiversityPriceIncreaseLimitPercent: 0
        spotInterruptionPredictionsEnabled: false
        spotInterruptionPredictionsType: string
        storageOptimized: false
        storageOptimizedState: string
        useSpotFallbacks: false
    customInstancesEnabled: false
    customInstancesWithExtendedMemoryEnabled: false
    customLabels:
        string: string
    customTaints:
        - effect: string
          key: string
          value: string
    isDefault: false
    isEnabled: false
    name: string
    nodeTemplateId: string
    rebalancingConfigMinNodes: 0
    shouldTaint: false
    timeouts:
        create: string
        delete: string
        read: string
        update: string

    NodeTemplate Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The NodeTemplate resource accepts the following input properties:

    ClusterId string
    CAST AI cluster id.
    ConfigurationId string
    CAST AI node configuration id to be used for node template.
    Constraints NodeTemplateConstraints
    CustomInstancesEnabled bool
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomInstancesWithExtendedMemoryEnabled bool
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomLabels Dictionary<string, string>
    Custom labels to be added to nodes created from this template.
    CustomTaints List<NodeTemplateCustomTaint>
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    IsDefault bool
    Flag whether the node template is default.
    IsEnabled bool
    Flag whether the node template is enabled and considered for autoscaling.
    Name string
    Name of the node template.
    NodeTemplateId string
    The ID of this resource.
    RebalancingConfigMinNodes double
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    ShouldTaint bool
    Marks whether the templated nodes will have a taint.
    Timeouts NodeTemplateTimeouts
    ClusterId string
    CAST AI cluster id.
    ConfigurationId string
    CAST AI node configuration id to be used for node template.
    Constraints NodeTemplateConstraintsArgs
    CustomInstancesEnabled bool
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomInstancesWithExtendedMemoryEnabled bool
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomLabels map[string]string
    Custom labels to be added to nodes created from this template.
    CustomTaints []NodeTemplateCustomTaintArgs
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    IsDefault bool
    Flag whether the node template is default.
    IsEnabled bool
    Flag whether the node template is enabled and considered for autoscaling.
    Name string
    Name of the node template.
    NodeTemplateId string
    The ID of this resource.
    RebalancingConfigMinNodes float64
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    ShouldTaint bool
    Marks whether the templated nodes will have a taint.
    Timeouts NodeTemplateTimeoutsArgs
    clusterId String
    CAST AI cluster id.
    configurationId String
    CAST AI node configuration id to be used for node template.
    constraints NodeTemplateConstraints
    customInstancesEnabled Boolean
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customInstancesWithExtendedMemoryEnabled Boolean
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customLabels Map<String,String>
    Custom labels to be added to nodes created from this template.
    customTaints List<NodeTemplateCustomTaint>
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    isDefault Boolean
    Flag whether the node template is default.
    isEnabled Boolean
    Flag whether the node template is enabled and considered for autoscaling.
    name String
    Name of the node template.
    nodeTemplateId String
    The ID of this resource.
    rebalancingConfigMinNodes Double
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    shouldTaint Boolean
    Marks whether the templated nodes will have a taint.
    timeouts NodeTemplateTimeouts
    clusterId string
    CAST AI cluster id.
    configurationId string
    CAST AI node configuration id to be used for node template.
    constraints NodeTemplateConstraints
    customInstancesEnabled boolean
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customInstancesWithExtendedMemoryEnabled boolean
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customLabels {[key: string]: string}
    Custom labels to be added to nodes created from this template.
    customTaints NodeTemplateCustomTaint[]
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    isDefault boolean
    Flag whether the node template is default.
    isEnabled boolean
    Flag whether the node template is enabled and considered for autoscaling.
    name string
    Name of the node template.
    nodeTemplateId string
    The ID of this resource.
    rebalancingConfigMinNodes number
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    shouldTaint boolean
    Marks whether the templated nodes will have a taint.
    timeouts NodeTemplateTimeouts
    cluster_id str
    CAST AI cluster id.
    configuration_id str
    CAST AI node configuration id to be used for node template.
    constraints NodeTemplateConstraintsArgs
    custom_instances_enabled bool
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    custom_instances_with_extended_memory_enabled bool
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    custom_labels Mapping[str, str]
    Custom labels to be added to nodes created from this template.
    custom_taints Sequence[NodeTemplateCustomTaintArgs]
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    is_default bool
    Flag whether the node template is default.
    is_enabled bool
    Flag whether the node template is enabled and considered for autoscaling.
    name str
    Name of the node template.
    node_template_id str
    The ID of this resource.
    rebalancing_config_min_nodes float
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    should_taint bool
    Marks whether the templated nodes will have a taint.
    timeouts NodeTemplateTimeoutsArgs
    clusterId String
    CAST AI cluster id.
    configurationId String
    CAST AI node configuration id to be used for node template.
    constraints Property Map
    customInstancesEnabled Boolean
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customInstancesWithExtendedMemoryEnabled Boolean
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customLabels Map<String>
    Custom labels to be added to nodes created from this template.
    customTaints List<Property Map>
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    isDefault Boolean
    Flag whether the node template is default.
    isEnabled Boolean
    Flag whether the node template is enabled and considered for autoscaling.
    name String
    Name of the node template.
    nodeTemplateId String
    The ID of this resource.
    rebalancingConfigMinNodes Number
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    shouldTaint Boolean
    Marks whether the templated nodes will have a taint.
    timeouts Property Map

    Outputs

    All input properties are implicitly available as output properties. Additionally, the NodeTemplate resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing NodeTemplate Resource

    Get an existing NodeTemplate resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: NodeTemplateState, opts?: CustomResourceOptions): NodeTemplate
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        cluster_id: Optional[str] = None,
        configuration_id: Optional[str] = None,
        constraints: Optional[NodeTemplateConstraintsArgs] = None,
        custom_instances_enabled: Optional[bool] = None,
        custom_instances_with_extended_memory_enabled: Optional[bool] = None,
        custom_labels: Optional[Mapping[str, str]] = None,
        custom_taints: Optional[Sequence[NodeTemplateCustomTaintArgs]] = None,
        is_default: Optional[bool] = None,
        is_enabled: Optional[bool] = None,
        name: Optional[str] = None,
        node_template_id: Optional[str] = None,
        rebalancing_config_min_nodes: Optional[float] = None,
        should_taint: Optional[bool] = None,
        timeouts: Optional[NodeTemplateTimeoutsArgs] = None) -> NodeTemplate
    func GetNodeTemplate(ctx *Context, name string, id IDInput, state *NodeTemplateState, opts ...ResourceOption) (*NodeTemplate, error)
    public static NodeTemplate Get(string name, Input<string> id, NodeTemplateState? state, CustomResourceOptions? opts = null)
    public static NodeTemplate get(String name, Output<String> id, NodeTemplateState state, CustomResourceOptions options)
    resources:  _:    type: castai:NodeTemplate    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ClusterId string
    CAST AI cluster id.
    ConfigurationId string
    CAST AI node configuration id to be used for node template.
    Constraints NodeTemplateConstraints
    CustomInstancesEnabled bool
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomInstancesWithExtendedMemoryEnabled bool
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomLabels Dictionary<string, string>
    Custom labels to be added to nodes created from this template.
    CustomTaints List<NodeTemplateCustomTaint>
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    IsDefault bool
    Flag whether the node template is default.
    IsEnabled bool
    Flag whether the node template is enabled and considered for autoscaling.
    Name string
    Name of the node template.
    NodeTemplateId string
    The ID of this resource.
    RebalancingConfigMinNodes double
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    ShouldTaint bool
    Marks whether the templated nodes will have a taint.
    Timeouts NodeTemplateTimeouts
    ClusterId string
    CAST AI cluster id.
    ConfigurationId string
    CAST AI node configuration id to be used for node template.
    Constraints NodeTemplateConstraintsArgs
    CustomInstancesEnabled bool
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomInstancesWithExtendedMemoryEnabled bool
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    CustomLabels map[string]string
    Custom labels to be added to nodes created from this template.
    CustomTaints []NodeTemplateCustomTaintArgs
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    IsDefault bool
    Flag whether the node template is default.
    IsEnabled bool
    Flag whether the node template is enabled and considered for autoscaling.
    Name string
    Name of the node template.
    NodeTemplateId string
    The ID of this resource.
    RebalancingConfigMinNodes float64
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    ShouldTaint bool
    Marks whether the templated nodes will have a taint.
    Timeouts NodeTemplateTimeoutsArgs
    clusterId String
    CAST AI cluster id.
    configurationId String
    CAST AI node configuration id to be used for node template.
    constraints NodeTemplateConstraints
    customInstancesEnabled Boolean
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customInstancesWithExtendedMemoryEnabled Boolean
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customLabels Map<String,String>
    Custom labels to be added to nodes created from this template.
    customTaints List<NodeTemplateCustomTaint>
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    isDefault Boolean
    Flag whether the node template is default.
    isEnabled Boolean
    Flag whether the node template is enabled and considered for autoscaling.
    name String
    Name of the node template.
    nodeTemplateId String
    The ID of this resource.
    rebalancingConfigMinNodes Double
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    shouldTaint Boolean
    Marks whether the templated nodes will have a taint.
    timeouts NodeTemplateTimeouts
    clusterId string
    CAST AI cluster id.
    configurationId string
    CAST AI node configuration id to be used for node template.
    constraints NodeTemplateConstraints
    customInstancesEnabled boolean
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customInstancesWithExtendedMemoryEnabled boolean
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customLabels {[key: string]: string}
    Custom labels to be added to nodes created from this template.
    customTaints NodeTemplateCustomTaint[]
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    isDefault boolean
    Flag whether the node template is default.
    isEnabled boolean
    Flag whether the node template is enabled and considered for autoscaling.
    name string
    Name of the node template.
    nodeTemplateId string
    The ID of this resource.
    rebalancingConfigMinNodes number
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    shouldTaint boolean
    Marks whether the templated nodes will have a taint.
    timeouts NodeTemplateTimeouts
    cluster_id str
    CAST AI cluster id.
    configuration_id str
    CAST AI node configuration id to be used for node template.
    constraints NodeTemplateConstraintsArgs
    custom_instances_enabled bool
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    custom_instances_with_extended_memory_enabled bool
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    custom_labels Mapping[str, str]
    Custom labels to be added to nodes created from this template.
    custom_taints Sequence[NodeTemplateCustomTaintArgs]
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    is_default bool
    Flag whether the node template is default.
    is_enabled bool
    Flag whether the node template is enabled and considered for autoscaling.
    name str
    Name of the node template.
    node_template_id str
    The ID of this resource.
    rebalancing_config_min_nodes float
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    should_taint bool
    Marks whether the templated nodes will have a taint.
    timeouts NodeTemplateTimeoutsArgs
    clusterId String
    CAST AI cluster id.
    configurationId String
    CAST AI node configuration id to be used for node template.
    constraints Property Map
    customInstancesEnabled Boolean
    Marks whether custom instances should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customInstancesWithExtendedMemoryEnabled Boolean
    Marks whether custom instances with extended memory should be used when deciding which parts of inventory are available. Custom instances are only supported in GCP.
    customLabels Map<String>
    Custom labels to be added to nodes created from this template.
    customTaints List<Property Map>
    Custom taints to be added to the nodes created from this template. shouldTaint has to be true in order to create/update the node template with custom taints. If shouldTaint is true, but no custom taints are provided, the nodes will be tainted with the default node template taint.
    isDefault Boolean
    Flag whether the node template is default.
    isEnabled Boolean
    Flag whether the node template is enabled and considered for autoscaling.
    name String
    Name of the node template.
    nodeTemplateId String
    The ID of this resource.
    rebalancingConfigMinNodes Number
    Minimum nodes that will be kept when rebalancing nodes using this node template.
    shouldTaint Boolean
    Marks whether the templated nodes will have a taint.
    timeouts Property Map

    Supporting Types

    NodeTemplateConstraints, NodeTemplateConstraintsArgs

    ArchitecturePriorities List<string>
    Priority ordering of architectures, specifying no priority will pick cheapest. Allowed values: amd64, arm64.
    Architectures List<string>
    List of acceptable instance CPU architectures, the default is amd64. Allowed values: amd64, arm64.
    Azs List<string>
    The list of AZ names to consider for the node template, if empty or not set all AZs are considered.
    BurstableInstances string
    Will include burstable instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    ComputeOptimized bool
    Compute optimized instance constraint (deprecated).
    ComputeOptimizedState string
    Will only include compute optimized nodes when enabled and exclude compute optimized nodes when disabled. Empty value won't have effect on instances filter. Supported values: enabled, disabled or empty string.
    CpuManufacturers List<string>
    List of acceptable CPU manufacturers. Allowed values: AMD, AMPERE, APPLE, AWS, INTEL.
    CustomPriorities List<NodeTemplateConstraintsCustomPriority>
    CustomerSpecific string
    Will include customer specific (preview) instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    DedicatedNodeAffinities List<NodeTemplateConstraintsDedicatedNodeAffinity>
    Dedicated node affinity - creates preference for instances to be created on sole tenancy or dedicated nodes. This feature is only available for GCP clusters and sole tenancy nodes with local SSDs or GPUs are not supported. If the sole tenancy or dedicated nodes don't have capacity for selected instance type, the Autoscaler will fall back to multi-tenant instance types available for this Node Template. Other instance constraints are applied when the Autoscaler picks available instance types that can be created on the sole tenancy or dedicated node (example: setting min CPU to 16).
    EnableSpotDiversity bool
    Enable/disable spot diversity policy. When enabled, autoscaler will try to balance between diverse and cost optimal instance types.
    FallbackRestoreRateSeconds double
    Fallback restore rate in seconds: defines how much time should pass before spot fallback should be attempted to be restored to real spot.
    Gpu NodeTemplateConstraintsGpu
    InstanceFamilies NodeTemplateConstraintsInstanceFamilies
    IsGpuOnly bool
    GPU instance constraint - will only pick nodes with GPU if true
    MaxCpu double
    Max CPU cores per node.
    MaxMemory double
    Max Memory (Mib) per node.
    MinCpu double
    Min CPU cores per node.
    MinMemory double
    Min Memory (Mib) per node.
    OnDemand bool
    Should include on-demand instances in the considered pool.
    Os List<string>
    List of acceptable instance Operating Systems, the default is linux. Allowed values: linux, windows.
    ResourceLimits NodeTemplateConstraintsResourceLimits
    Spot bool
    Should include spot instances in the considered pool.
    SpotDiversityPriceIncreaseLimitPercent double
    Allowed node configuration price increase when diversifying instance types. E.g. if the value is 10%, then the overall price of diversified instance types can be 10% higher than the price of the optimal configuration.
    SpotInterruptionPredictionsEnabled bool
    Enable/disable spot interruption predictions.
    SpotInterruptionPredictionsType string
    Spot interruption predictions type. Can be either "aws-rebalance-recommendations" or "interruption-predictions".
    StorageOptimized bool
    Storage optimized instance constraint (deprecated).
    StorageOptimizedState string
    Storage optimized instance constraint - will only pick storage optimized nodes if enabled and won't pick if disabled. Empty value will have no effect. Supported values: enabled, disabled or empty string.
    UseSpotFallbacks bool
    Spot instance fallback constraint - when true, on-demand instances will be created, when spots are unavailable.
    ArchitecturePriorities []string
    Priority ordering of architectures, specifying no priority will pick cheapest. Allowed values: amd64, arm64.
    Architectures []string
    List of acceptable instance CPU architectures, the default is amd64. Allowed values: amd64, arm64.
    Azs []string
    The list of AZ names to consider for the node template, if empty or not set all AZs are considered.
    BurstableInstances string
    Will include burstable instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    ComputeOptimized bool
    Compute optimized instance constraint (deprecated).
    ComputeOptimizedState string
    Will only include compute optimized nodes when enabled and exclude compute optimized nodes when disabled. Empty value won't have effect on instances filter. Supported values: enabled, disabled or empty string.
    CpuManufacturers []string
    List of acceptable CPU manufacturers. Allowed values: AMD, AMPERE, APPLE, AWS, INTEL.
    CustomPriorities []NodeTemplateConstraintsCustomPriority
    CustomerSpecific string
    Will include customer specific (preview) instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    DedicatedNodeAffinities []NodeTemplateConstraintsDedicatedNodeAffinity
    Dedicated node affinity - creates preference for instances to be created on sole tenancy or dedicated nodes. This feature is only available for GCP clusters and sole tenancy nodes with local SSDs or GPUs are not supported. If the sole tenancy or dedicated nodes don't have capacity for selected instance type, the Autoscaler will fall back to multi-tenant instance types available for this Node Template. Other instance constraints are applied when the Autoscaler picks available instance types that can be created on the sole tenancy or dedicated node (example: setting min CPU to 16).
    EnableSpotDiversity bool
    Enable/disable spot diversity policy. When enabled, autoscaler will try to balance between diverse and cost optimal instance types.
    FallbackRestoreRateSeconds float64
    Fallback restore rate in seconds: defines how much time should pass before spot fallback should be attempted to be restored to real spot.
    Gpu NodeTemplateConstraintsGpu
    InstanceFamilies NodeTemplateConstraintsInstanceFamilies
    IsGpuOnly bool
    GPU instance constraint - will only pick nodes with GPU if true
    MaxCpu float64
    Max CPU cores per node.
    MaxMemory float64
    Max Memory (Mib) per node.
    MinCpu float64
    Min CPU cores per node.
    MinMemory float64
    Min Memory (Mib) per node.
    OnDemand bool
    Should include on-demand instances in the considered pool.
    Os []string
    List of acceptable instance Operating Systems, the default is linux. Allowed values: linux, windows.
    ResourceLimits NodeTemplateConstraintsResourceLimits
    Spot bool
    Should include spot instances in the considered pool.
    SpotDiversityPriceIncreaseLimitPercent float64
    Allowed node configuration price increase when diversifying instance types. E.g. if the value is 10%, then the overall price of diversified instance types can be 10% higher than the price of the optimal configuration.
    SpotInterruptionPredictionsEnabled bool
    Enable/disable spot interruption predictions.
    SpotInterruptionPredictionsType string
    Spot interruption predictions type. Can be either "aws-rebalance-recommendations" or "interruption-predictions".
    StorageOptimized bool
    Storage optimized instance constraint (deprecated).
    StorageOptimizedState string
    Storage optimized instance constraint - will only pick storage optimized nodes if enabled and won't pick if disabled. Empty value will have no effect. Supported values: enabled, disabled or empty string.
    UseSpotFallbacks bool
    Spot instance fallback constraint - when true, on-demand instances will be created, when spots are unavailable.
    architecturePriorities List<String>
    Priority ordering of architectures, specifying no priority will pick cheapest. Allowed values: amd64, arm64.
    architectures List<String>
    List of acceptable instance CPU architectures, the default is amd64. Allowed values: amd64, arm64.
    azs List<String>
    The list of AZ names to consider for the node template, if empty or not set all AZs are considered.
    burstableInstances String
    Will include burstable instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    computeOptimized Boolean
    Compute optimized instance constraint (deprecated).
    computeOptimizedState String
    Will only include compute optimized nodes when enabled and exclude compute optimized nodes when disabled. Empty value won't have effect on instances filter. Supported values: enabled, disabled or empty string.
    cpuManufacturers List<String>
    List of acceptable CPU manufacturers. Allowed values: AMD, AMPERE, APPLE, AWS, INTEL.
    customPriorities List<NodeTemplateConstraintsCustomPriority>
    customerSpecific String
    Will include customer specific (preview) instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    dedicatedNodeAffinities List<NodeTemplateConstraintsDedicatedNodeAffinity>
    Dedicated node affinity - creates preference for instances to be created on sole tenancy or dedicated nodes. This feature is only available for GCP clusters and sole tenancy nodes with local SSDs or GPUs are not supported. If the sole tenancy or dedicated nodes don't have capacity for selected instance type, the Autoscaler will fall back to multi-tenant instance types available for this Node Template. Other instance constraints are applied when the Autoscaler picks available instance types that can be created on the sole tenancy or dedicated node (example: setting min CPU to 16).
    enableSpotDiversity Boolean
    Enable/disable spot diversity policy. When enabled, autoscaler will try to balance between diverse and cost optimal instance types.
    fallbackRestoreRateSeconds Double
    Fallback restore rate in seconds: defines how much time should pass before spot fallback should be attempted to be restored to real spot.
    gpu NodeTemplateConstraintsGpu
    instanceFamilies NodeTemplateConstraintsInstanceFamilies
    isGpuOnly Boolean
    GPU instance constraint - will only pick nodes with GPU if true
    maxCpu Double
    Max CPU cores per node.
    maxMemory Double
    Max Memory (Mib) per node.
    minCpu Double
    Min CPU cores per node.
    minMemory Double
    Min Memory (Mib) per node.
    onDemand Boolean
    Should include on-demand instances in the considered pool.
    os List<String>
    List of acceptable instance Operating Systems, the default is linux. Allowed values: linux, windows.
    resourceLimits NodeTemplateConstraintsResourceLimits
    spot Boolean
    Should include spot instances in the considered pool.
    spotDiversityPriceIncreaseLimitPercent Double
    Allowed node configuration price increase when diversifying instance types. E.g. if the value is 10%, then the overall price of diversified instance types can be 10% higher than the price of the optimal configuration.
    spotInterruptionPredictionsEnabled Boolean
    Enable/disable spot interruption predictions.
    spotInterruptionPredictionsType String
    Spot interruption predictions type. Can be either "aws-rebalance-recommendations" or "interruption-predictions".
    storageOptimized Boolean
    Storage optimized instance constraint (deprecated).
    storageOptimizedState String
    Storage optimized instance constraint - will only pick storage optimized nodes if enabled and won't pick if disabled. Empty value will have no effect. Supported values: enabled, disabled or empty string.
    useSpotFallbacks Boolean
    Spot instance fallback constraint - when true, on-demand instances will be created, when spots are unavailable.
    architecturePriorities string[]
    Priority ordering of architectures, specifying no priority will pick cheapest. Allowed values: amd64, arm64.
    architectures string[]
    List of acceptable instance CPU architectures, the default is amd64. Allowed values: amd64, arm64.
    azs string[]
    The list of AZ names to consider for the node template, if empty or not set all AZs are considered.
    burstableInstances string
    Will include burstable instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    computeOptimized boolean
    Compute optimized instance constraint (deprecated).
    computeOptimizedState string
    Will only include compute optimized nodes when enabled and exclude compute optimized nodes when disabled. Empty value won't have effect on instances filter. Supported values: enabled, disabled or empty string.
    cpuManufacturers string[]
    List of acceptable CPU manufacturers. Allowed values: AMD, AMPERE, APPLE, AWS, INTEL.
    customPriorities NodeTemplateConstraintsCustomPriority[]
    customerSpecific string
    Will include customer specific (preview) instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    dedicatedNodeAffinities NodeTemplateConstraintsDedicatedNodeAffinity[]
    Dedicated node affinity - creates preference for instances to be created on sole tenancy or dedicated nodes. This feature is only available for GCP clusters and sole tenancy nodes with local SSDs or GPUs are not supported. If the sole tenancy or dedicated nodes don't have capacity for selected instance type, the Autoscaler will fall back to multi-tenant instance types available for this Node Template. Other instance constraints are applied when the Autoscaler picks available instance types that can be created on the sole tenancy or dedicated node (example: setting min CPU to 16).
    enableSpotDiversity boolean
    Enable/disable spot diversity policy. When enabled, autoscaler will try to balance between diverse and cost optimal instance types.
    fallbackRestoreRateSeconds number
    Fallback restore rate in seconds: defines how much time should pass before spot fallback should be attempted to be restored to real spot.
    gpu NodeTemplateConstraintsGpu
    instanceFamilies NodeTemplateConstraintsInstanceFamilies
    isGpuOnly boolean
    GPU instance constraint - will only pick nodes with GPU if true
    maxCpu number
    Max CPU cores per node.
    maxMemory number
    Max Memory (Mib) per node.
    minCpu number
    Min CPU cores per node.
    minMemory number
    Min Memory (Mib) per node.
    onDemand boolean
    Should include on-demand instances in the considered pool.
    os string[]
    List of acceptable instance Operating Systems, the default is linux. Allowed values: linux, windows.
    resourceLimits NodeTemplateConstraintsResourceLimits
    spot boolean
    Should include spot instances in the considered pool.
    spotDiversityPriceIncreaseLimitPercent number
    Allowed node configuration price increase when diversifying instance types. E.g. if the value is 10%, then the overall price of diversified instance types can be 10% higher than the price of the optimal configuration.
    spotInterruptionPredictionsEnabled boolean
    Enable/disable spot interruption predictions.
    spotInterruptionPredictionsType string
    Spot interruption predictions type. Can be either "aws-rebalance-recommendations" or "interruption-predictions".
    storageOptimized boolean
    Storage optimized instance constraint (deprecated).
    storageOptimizedState string
    Storage optimized instance constraint - will only pick storage optimized nodes if enabled and won't pick if disabled. Empty value will have no effect. Supported values: enabled, disabled or empty string.
    useSpotFallbacks boolean
    Spot instance fallback constraint - when true, on-demand instances will be created, when spots are unavailable.
    architecture_priorities Sequence[str]
    Priority ordering of architectures, specifying no priority will pick cheapest. Allowed values: amd64, arm64.
    architectures Sequence[str]
    List of acceptable instance CPU architectures, the default is amd64. Allowed values: amd64, arm64.
    azs Sequence[str]
    The list of AZ names to consider for the node template, if empty or not set all AZs are considered.
    burstable_instances str
    Will include burstable instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    compute_optimized bool
    Compute optimized instance constraint (deprecated).
    compute_optimized_state str
    Will only include compute optimized nodes when enabled and exclude compute optimized nodes when disabled. Empty value won't have effect on instances filter. Supported values: enabled, disabled or empty string.
    cpu_manufacturers Sequence[str]
    List of acceptable CPU manufacturers. Allowed values: AMD, AMPERE, APPLE, AWS, INTEL.
    custom_priorities Sequence[NodeTemplateConstraintsCustomPriority]
    customer_specific str
    Will include customer specific (preview) instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    dedicated_node_affinities Sequence[NodeTemplateConstraintsDedicatedNodeAffinity]
    Dedicated node affinity - creates preference for instances to be created on sole tenancy or dedicated nodes. This feature is only available for GCP clusters and sole tenancy nodes with local SSDs or GPUs are not supported. If the sole tenancy or dedicated nodes don't have capacity for selected instance type, the Autoscaler will fall back to multi-tenant instance types available for this Node Template. Other instance constraints are applied when the Autoscaler picks available instance types that can be created on the sole tenancy or dedicated node (example: setting min CPU to 16).
    enable_spot_diversity bool
    Enable/disable spot diversity policy. When enabled, autoscaler will try to balance between diverse and cost optimal instance types.
    fallback_restore_rate_seconds float
    Fallback restore rate in seconds: defines how much time should pass before spot fallback should be attempted to be restored to real spot.
    gpu NodeTemplateConstraintsGpu
    instance_families NodeTemplateConstraintsInstanceFamilies
    is_gpu_only bool
    GPU instance constraint - will only pick nodes with GPU if true
    max_cpu float
    Max CPU cores per node.
    max_memory float
    Max Memory (Mib) per node.
    min_cpu float
    Min CPU cores per node.
    min_memory float
    Min Memory (Mib) per node.
    on_demand bool
    Should include on-demand instances in the considered pool.
    os Sequence[str]
    List of acceptable instance Operating Systems, the default is linux. Allowed values: linux, windows.
    resource_limits NodeTemplateConstraintsResourceLimits
    spot bool
    Should include spot instances in the considered pool.
    spot_diversity_price_increase_limit_percent float
    Allowed node configuration price increase when diversifying instance types. E.g. if the value is 10%, then the overall price of diversified instance types can be 10% higher than the price of the optimal configuration.
    spot_interruption_predictions_enabled bool
    Enable/disable spot interruption predictions.
    spot_interruption_predictions_type str
    Spot interruption predictions type. Can be either "aws-rebalance-recommendations" or "interruption-predictions".
    storage_optimized bool
    Storage optimized instance constraint (deprecated).
    storage_optimized_state str
    Storage optimized instance constraint - will only pick storage optimized nodes if enabled and won't pick if disabled. Empty value will have no effect. Supported values: enabled, disabled or empty string.
    use_spot_fallbacks bool
    Spot instance fallback constraint - when true, on-demand instances will be created, when spots are unavailable.
    architecturePriorities List<String>
    Priority ordering of architectures, specifying no priority will pick cheapest. Allowed values: amd64, arm64.
    architectures List<String>
    List of acceptable instance CPU architectures, the default is amd64. Allowed values: amd64, arm64.
    azs List<String>
    The list of AZ names to consider for the node template, if empty or not set all AZs are considered.
    burstableInstances String
    Will include burstable instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    computeOptimized Boolean
    Compute optimized instance constraint (deprecated).
    computeOptimizedState String
    Will only include compute optimized nodes when enabled and exclude compute optimized nodes when disabled. Empty value won't have effect on instances filter. Supported values: enabled, disabled or empty string.
    cpuManufacturers List<String>
    List of acceptable CPU manufacturers. Allowed values: AMD, AMPERE, APPLE, AWS, INTEL.
    customPriorities List<Property Map>
    customerSpecific String
    Will include customer specific (preview) instances when enabled otherwise they will be excluded. Supported values: enabled, disabled or ``.
    dedicatedNodeAffinities List<Property Map>
    Dedicated node affinity - creates preference for instances to be created on sole tenancy or dedicated nodes. This feature is only available for GCP clusters and sole tenancy nodes with local SSDs or GPUs are not supported. If the sole tenancy or dedicated nodes don't have capacity for selected instance type, the Autoscaler will fall back to multi-tenant instance types available for this Node Template. Other instance constraints are applied when the Autoscaler picks available instance types that can be created on the sole tenancy or dedicated node (example: setting min CPU to 16).
    enableSpotDiversity Boolean
    Enable/disable spot diversity policy. When enabled, autoscaler will try to balance between diverse and cost optimal instance types.
    fallbackRestoreRateSeconds Number
    Fallback restore rate in seconds: defines how much time should pass before spot fallback should be attempted to be restored to real spot.
    gpu Property Map
    instanceFamilies Property Map
    isGpuOnly Boolean
    GPU instance constraint - will only pick nodes with GPU if true
    maxCpu Number
    Max CPU cores per node.
    maxMemory Number
    Max Memory (Mib) per node.
    minCpu Number
    Min CPU cores per node.
    minMemory Number
    Min Memory (Mib) per node.
    onDemand Boolean
    Should include on-demand instances in the considered pool.
    os List<String>
    List of acceptable instance Operating Systems, the default is linux. Allowed values: linux, windows.
    resourceLimits Property Map
    spot Boolean
    Should include spot instances in the considered pool.
    spotDiversityPriceIncreaseLimitPercent Number
    Allowed node configuration price increase when diversifying instance types. E.g. if the value is 10%, then the overall price of diversified instance types can be 10% higher than the price of the optimal configuration.
    spotInterruptionPredictionsEnabled Boolean
    Enable/disable spot interruption predictions.
    spotInterruptionPredictionsType String
    Spot interruption predictions type. Can be either "aws-rebalance-recommendations" or "interruption-predictions".
    storageOptimized Boolean
    Storage optimized instance constraint (deprecated).
    storageOptimizedState String
    Storage optimized instance constraint - will only pick storage optimized nodes if enabled and won't pick if disabled. Empty value will have no effect. Supported values: enabled, disabled or empty string.
    useSpotFallbacks Boolean
    Spot instance fallback constraint - when true, on-demand instances will be created, when spots are unavailable.

    NodeTemplateConstraintsCustomPriority, NodeTemplateConstraintsCustomPriorityArgs

    InstanceFamilies List<string>
    Instance families to prioritize in this tier.
    OnDemand bool
    If true, this tier will apply to on-demand instances.
    Spot bool
    If true, this tier will apply to spot instances.
    InstanceFamilies []string
    Instance families to prioritize in this tier.
    OnDemand bool
    If true, this tier will apply to on-demand instances.
    Spot bool
    If true, this tier will apply to spot instances.
    instanceFamilies List<String>
    Instance families to prioritize in this tier.
    onDemand Boolean
    If true, this tier will apply to on-demand instances.
    spot Boolean
    If true, this tier will apply to spot instances.
    instanceFamilies string[]
    Instance families to prioritize in this tier.
    onDemand boolean
    If true, this tier will apply to on-demand instances.
    spot boolean
    If true, this tier will apply to spot instances.
    instance_families Sequence[str]
    Instance families to prioritize in this tier.
    on_demand bool
    If true, this tier will apply to on-demand instances.
    spot bool
    If true, this tier will apply to spot instances.
    instanceFamilies List<String>
    Instance families to prioritize in this tier.
    onDemand Boolean
    If true, this tier will apply to on-demand instances.
    spot Boolean
    If true, this tier will apply to spot instances.

    NodeTemplateConstraintsDedicatedNodeAffinity, NodeTemplateConstraintsDedicatedNodeAffinityArgs

    AzName string
    Availability zone name.
    InstanceTypes List<string>
    Instance/node types in this node group.
    Name string
    Name of node group.
    Affinities List<NodeTemplateConstraintsDedicatedNodeAffinityAffinity>
    AzName string
    Availability zone name.
    InstanceTypes []string
    Instance/node types in this node group.
    Name string
    Name of node group.
    Affinities []NodeTemplateConstraintsDedicatedNodeAffinityAffinity
    azName String
    Availability zone name.
    instanceTypes List<String>
    Instance/node types in this node group.
    name String
    Name of node group.
    affinities List<NodeTemplateConstraintsDedicatedNodeAffinityAffinity>
    azName string
    Availability zone name.
    instanceTypes string[]
    Instance/node types in this node group.
    name string
    Name of node group.
    affinities NodeTemplateConstraintsDedicatedNodeAffinityAffinity[]
    az_name str
    Availability zone name.
    instance_types Sequence[str]
    Instance/node types in this node group.
    name str
    Name of node group.
    affinities Sequence[NodeTemplateConstraintsDedicatedNodeAffinityAffinity]
    azName String
    Availability zone name.
    instanceTypes List<String>
    Instance/node types in this node group.
    name String
    Name of node group.
    affinities List<Property Map>

    NodeTemplateConstraintsDedicatedNodeAffinityAffinity, NodeTemplateConstraintsDedicatedNodeAffinityAffinityArgs

    Key string
    Key of the node affinity selector.
    Operator string
    Operator of the node affinity selector. Allowed values: In, NotIn, Exists, DoesNotExist, Gt, Lt.
    Values List<string>
    Values of the node affinity selector.
    Key string
    Key of the node affinity selector.
    Operator string
    Operator of the node affinity selector. Allowed values: In, NotIn, Exists, DoesNotExist, Gt, Lt.
    Values []string
    Values of the node affinity selector.
    key String
    Key of the node affinity selector.
    operator String
    Operator of the node affinity selector. Allowed values: In, NotIn, Exists, DoesNotExist, Gt, Lt.
    values List<String>
    Values of the node affinity selector.
    key string
    Key of the node affinity selector.
    operator string
    Operator of the node affinity selector. Allowed values: In, NotIn, Exists, DoesNotExist, Gt, Lt.
    values string[]
    Values of the node affinity selector.
    key str
    Key of the node affinity selector.
    operator str
    Operator of the node affinity selector. Allowed values: In, NotIn, Exists, DoesNotExist, Gt, Lt.
    values Sequence[str]
    Values of the node affinity selector.
    key String
    Key of the node affinity selector.
    operator String
    Operator of the node affinity selector. Allowed values: In, NotIn, Exists, DoesNotExist, Gt, Lt.
    values List<String>
    Values of the node affinity selector.

    NodeTemplateConstraintsGpu, NodeTemplateConstraintsGpuArgs

    ExcludeNames List<string>
    Names of the GPUs to exclude.
    IncludeNames List<string>
    Instance families to include when filtering (excludes all other families).
    Manufacturers List<string>
    Manufacturers of the gpus to select - NVIDIA, AMD.
    MaxCount double
    Max GPU count for the instance type to have.
    MinCount double
    Min GPU count for the instance type to have.
    ExcludeNames []string
    Names of the GPUs to exclude.
    IncludeNames []string
    Instance families to include when filtering (excludes all other families).
    Manufacturers []string
    Manufacturers of the gpus to select - NVIDIA, AMD.
    MaxCount float64
    Max GPU count for the instance type to have.
    MinCount float64
    Min GPU count for the instance type to have.
    excludeNames List<String>
    Names of the GPUs to exclude.
    includeNames List<String>
    Instance families to include when filtering (excludes all other families).
    manufacturers List<String>
    Manufacturers of the gpus to select - NVIDIA, AMD.
    maxCount Double
    Max GPU count for the instance type to have.
    minCount Double
    Min GPU count for the instance type to have.
    excludeNames string[]
    Names of the GPUs to exclude.
    includeNames string[]
    Instance families to include when filtering (excludes all other families).
    manufacturers string[]
    Manufacturers of the gpus to select - NVIDIA, AMD.
    maxCount number
    Max GPU count for the instance type to have.
    minCount number
    Min GPU count for the instance type to have.
    exclude_names Sequence[str]
    Names of the GPUs to exclude.
    include_names Sequence[str]
    Instance families to include when filtering (excludes all other families).
    manufacturers Sequence[str]
    Manufacturers of the gpus to select - NVIDIA, AMD.
    max_count float
    Max GPU count for the instance type to have.
    min_count float
    Min GPU count for the instance type to have.
    excludeNames List<String>
    Names of the GPUs to exclude.
    includeNames List<String>
    Instance families to include when filtering (excludes all other families).
    manufacturers List<String>
    Manufacturers of the gpus to select - NVIDIA, AMD.
    maxCount Number
    Max GPU count for the instance type to have.
    minCount Number
    Min GPU count for the instance type to have.

    NodeTemplateConstraintsInstanceFamilies, NodeTemplateConstraintsInstanceFamiliesArgs

    Excludes List<string>
    Instance families to include when filtering (excludes all other families).
    Includes List<string>
    Instance families to exclude when filtering (includes all other families).
    Excludes []string
    Instance families to include when filtering (excludes all other families).
    Includes []string
    Instance families to exclude when filtering (includes all other families).
    excludes List<String>
    Instance families to include when filtering (excludes all other families).
    includes List<String>
    Instance families to exclude when filtering (includes all other families).
    excludes string[]
    Instance families to include when filtering (excludes all other families).
    includes string[]
    Instance families to exclude when filtering (includes all other families).
    excludes Sequence[str]
    Instance families to include when filtering (excludes all other families).
    includes Sequence[str]
    Instance families to exclude when filtering (includes all other families).
    excludes List<String>
    Instance families to include when filtering (excludes all other families).
    includes List<String>
    Instance families to exclude when filtering (includes all other families).

    NodeTemplateConstraintsResourceLimits, NodeTemplateConstraintsResourceLimitsArgs

    CpuLimitEnabled bool
    Controls CPU limit enforcement for the node template.
    CpuLimitMaxCores double
    Specifies the maximum number of CPU cores that the nodes provisioned from this template can collectively have.
    CpuLimitEnabled bool
    Controls CPU limit enforcement for the node template.
    CpuLimitMaxCores float64
    Specifies the maximum number of CPU cores that the nodes provisioned from this template can collectively have.
    cpuLimitEnabled Boolean
    Controls CPU limit enforcement for the node template.
    cpuLimitMaxCores Double
    Specifies the maximum number of CPU cores that the nodes provisioned from this template can collectively have.
    cpuLimitEnabled boolean
    Controls CPU limit enforcement for the node template.
    cpuLimitMaxCores number
    Specifies the maximum number of CPU cores that the nodes provisioned from this template can collectively have.
    cpu_limit_enabled bool
    Controls CPU limit enforcement for the node template.
    cpu_limit_max_cores float
    Specifies the maximum number of CPU cores that the nodes provisioned from this template can collectively have.
    cpuLimitEnabled Boolean
    Controls CPU limit enforcement for the node template.
    cpuLimitMaxCores Number
    Specifies the maximum number of CPU cores that the nodes provisioned from this template can collectively have.

    NodeTemplateCustomTaint, NodeTemplateCustomTaintArgs

    Key string
    Key of a taint to be added to nodes created from this template.
    Effect string
    Effect of a taint to be added to nodes created from this template, the default is NoSchedule. Allowed values: NoSchedule, NoExecute.
    Value string
    Value of a taint to be added to nodes created from this template.
    Key string
    Key of a taint to be added to nodes created from this template.
    Effect string
    Effect of a taint to be added to nodes created from this template, the default is NoSchedule. Allowed values: NoSchedule, NoExecute.
    Value string
    Value of a taint to be added to nodes created from this template.
    key String
    Key of a taint to be added to nodes created from this template.
    effect String
    Effect of a taint to be added to nodes created from this template, the default is NoSchedule. Allowed values: NoSchedule, NoExecute.
    value String
    Value of a taint to be added to nodes created from this template.
    key string
    Key of a taint to be added to nodes created from this template.
    effect string
    Effect of a taint to be added to nodes created from this template, the default is NoSchedule. Allowed values: NoSchedule, NoExecute.
    value string
    Value of a taint to be added to nodes created from this template.
    key str
    Key of a taint to be added to nodes created from this template.
    effect str
    Effect of a taint to be added to nodes created from this template, the default is NoSchedule. Allowed values: NoSchedule, NoExecute.
    value str
    Value of a taint to be added to nodes created from this template.
    key String
    Key of a taint to be added to nodes created from this template.
    effect String
    Effect of a taint to be added to nodes created from this template, the default is NoSchedule. Allowed values: NoSchedule, NoExecute.
    value String
    Value of a taint to be added to nodes created from this template.

    NodeTemplateTimeouts, NodeTemplateTimeoutsArgs

    Create string
    Delete string
    Read string
    Update string
    Create string
    Delete string
    Read string
    Update string
    create String
    delete String
    read String
    update String
    create string
    delete string
    read string
    update string
    create str
    delete str
    read str
    update str
    create String
    delete String
    read String
    update String

    Import

    Import node template by specifying cluster ID and node template name.

    $ pulumi import castai:index/nodeTemplate:NodeTemplate default_by_castai 105e6fa3-20b1-424e-v589-9a64d1eeabea/default-by-castai

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    castai castai/terraform-provider-castai
    License
    Notes
    This Pulumi package is based on the castai Terraform Provider.
    castai logo
    castai 7.44.0 published on Friday, Mar 21, 2025 by castai
    castai/terraform-provider-castai