pulumi-azure-native-kotlin/com.pulumi.azurenative.containerservice.kotlin/AgentPoolArgs

AgentPoolArgs

data class AgentPoolArgs(val agentPoolName: Output<String>? = null, val availabilityZones: Output<List<String>>? = null, val count: Output<Int>? = null, val enableAutoScaling: Output<Boolean>? = null, val enableEncryptionAtHost: Output<Boolean>? = null, val enableFIPS: Output<Boolean>? = null, val enableNodePublicIP: Output<Boolean>? = null, val gpuInstanceProfile: Output<Either<String, GPUInstanceProfile>>? = null, val kubeletConfig: Output<KubeletConfigArgs>? = null, val kubeletDiskType: Output<Either<String, KubeletDiskType>>? = null, val linuxOSConfig: Output<LinuxOSConfigArgs>? = null, val maxCount: Output<Int>? = null, val maxPods: Output<Int>? = null, val minCount: Output<Int>? = null, val mode: Output<Either<String, AgentPoolMode>>? = null, val nodeLabels: Output<Map<String, String>>? = null, val nodePublicIPPrefixID: Output<String>? = null, val nodeTaints: Output<List<String>>? = null, val orchestratorVersion: Output<String>? = null, val osDiskSizeGB: Output<Int>? = null, val osDiskType: Output<Either<String, OSDiskType>>? = null, val osSKU: Output<Either<String, OSSKU>>? = null, val osType: Output<Either<String, OSType>>? = null, val podSubnetID: Output<String>? = null, val proximityPlacementGroupID: Output<String>? = null, val resourceGroupName: Output<String>? = null, val resourceName: Output<String>? = null, val scaleSetEvictionPolicy: Output<Either<String, ScaleSetEvictionPolicy>>? = null, val scaleSetPriority: Output<Either<String, ScaleSetPriority>>? = null, val spotMaxPrice: Output<Double>? = null, val tags: Output<Map<String, String>>? = null, val type: Output<Either<String, AgentPoolType>>? = null, val upgradeSettings: Output<AgentPoolUpgradeSettingsArgs>? = null, val vmSize: Output<String>? = null, val vnetSubnetID: Output<String>? = null) : ConvertibleToJava<AgentPoolArgs>

Agent Pool. API Version: 2021-03-01.

Example Usage

Create Agent Pool with EncryptionAtHost enabled

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        EnableEncryptionAtHost = true,
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_DS2_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName:          pulumi.String("agentpool1"),
			Count:                  pulumi.Int(3),
			EnableEncryptionAtHost: pulumi.Bool(true),
			OrchestratorVersion:    pulumi.String(""),
			OsType:                 pulumi.String("Linux"),
			ResourceGroupName:      pulumi.String("rg1"),
			ResourceName:           pulumi.String("clustername1"),
			VmSize:                 pulumi.String("Standard_DS2_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .enableEncryptionAtHost(true)
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_DS2_v2")
            .build());
    }
}
Content copied to clipboard

Create Agent Pool with Ephemeral OS Disk

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        OrchestratorVersion = "",
        OsDiskSizeGB = 64,
        OsDiskType = "Ephemeral",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_DS2_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName:       pulumi.String("agentpool1"),
			Count:               pulumi.Int(3),
			OrchestratorVersion: pulumi.String(""),
			OsDiskSizeGB:        pulumi.Int(64),
			OsDiskType:          pulumi.String("Ephemeral"),
			OsType:              pulumi.String("Linux"),
			ResourceGroupName:   pulumi.String("rg1"),
			ResourceName:        pulumi.String("clustername1"),
			VmSize:              pulumi.String("Standard_DS2_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .orchestratorVersion("")
            .osDiskSizeGB(64)
            .osDiskType("Ephemeral")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_DS2_v2")
            .build());
    }
}
Content copied to clipboard

Create Agent Pool with FIPS enabled OS

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        EnableFIPS = true,
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_DS2_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName:       pulumi.String("agentpool1"),
			Count:               pulumi.Int(3),
			EnableFIPS:          pulumi.Bool(true),
			OrchestratorVersion: pulumi.String(""),
			OsType:              pulumi.String("Linux"),
			ResourceGroupName:   pulumi.String("rg1"),
			ResourceName:        pulumi.String("clustername1"),
			VmSize:              pulumi.String("Standard_DS2_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .enableFIPS(true)
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_DS2_v2")
            .build());
    }
}
Content copied to clipboard

Create Agent Pool with GPUMIG

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        GpuInstanceProfile = "MIG2g",
        KubeletConfig = new AzureNative.ContainerService.Inputs.KubeletConfigArgs
        {
            AllowedUnsafeSysctls = new[]
            {
                "kernel.msg*",
                "net.core.somaxconn",
            },
            CpuCfsQuota = true,
            CpuCfsQuotaPeriod = "200ms",
            CpuManagerPolicy = "static",
            FailSwapOn = false,
            ImageGcHighThreshold = 90,
            ImageGcLowThreshold = 70,
            TopologyManagerPolicy = "best-effort",
        },
        LinuxOSConfig = new AzureNative.ContainerService.Inputs.LinuxOSConfigArgs
        {
            SwapFileSizeMB = 1500,
            Sysctls = new AzureNative.ContainerService.Inputs.SysctlConfigArgs
            {
                KernelThreadsMax = 99999,
                NetCoreWmemDefault = 12345,
                NetIpv4IpLocalPortRange = "20000 60000",
                NetIpv4TcpTwReuse = true,
            },
            TransparentHugePageDefrag = "madvise",
            TransparentHugePageEnabled = "always",
        },
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_ND96asr_v4",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName:      pulumi.String("agentpool1"),
			Count:              pulumi.Int(3),
			GpuInstanceProfile: pulumi.String("MIG2g"),
			KubeletConfig: &containerservice.KubeletConfigArgs{
				AllowedUnsafeSysctls: pulumi.StringArray{
					pulumi.String("kernel.msg*"),
					pulumi.String("net.core.somaxconn"),
				},
				CpuCfsQuota:           pulumi.Bool(true),
				CpuCfsQuotaPeriod:     pulumi.String("200ms"),
				CpuManagerPolicy:      pulumi.String("static"),
				FailSwapOn:            pulumi.Bool(false),
				ImageGcHighThreshold:  pulumi.Int(90),
				ImageGcLowThreshold:   pulumi.Int(70),
				TopologyManagerPolicy: pulumi.String("best-effort"),
			},
			LinuxOSConfig: containerservice.LinuxOSConfigResponse{
				SwapFileSizeMB: pulumi.Int(1500),
				Sysctls: &containerservice.SysctlConfigArgs{
					KernelThreadsMax:        pulumi.Int(99999),
					NetCoreWmemDefault:      pulumi.Int(12345),
					NetIpv4IpLocalPortRange: pulumi.String("20000 60000"),
					NetIpv4TcpTwReuse:       pulumi.Bool(true),
				},
				TransparentHugePageDefrag:  pulumi.String("madvise"),
				TransparentHugePageEnabled: pulumi.String("always"),
			},
			OrchestratorVersion: pulumi.String(""),
			OsType:              pulumi.String("Linux"),
			ResourceGroupName:   pulumi.String("rg1"),
			ResourceName:        pulumi.String("clustername1"),
			VmSize:              pulumi.String("Standard_ND96asr_v4"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .gpuInstanceProfile("MIG2g")
            .kubeletConfig(Map.ofEntries(
                Map.entry("allowedUnsafeSysctls",
                    "kernel.msg*",
                    "net.core.somaxconn"),
                Map.entry("cpuCfsQuota", true),
                Map.entry("cpuCfsQuotaPeriod", "200ms"),
                Map.entry("cpuManagerPolicy", "static"),
                Map.entry("failSwapOn", false),
                Map.entry("imageGcHighThreshold", 90),
                Map.entry("imageGcLowThreshold", 70),
                Map.entry("topologyManagerPolicy", "best-effort")
            ))
            .linuxOSConfig(Map.ofEntries(
                Map.entry("swapFileSizeMB", 1500),
                Map.entry("sysctls", Map.ofEntries(
                    Map.entry("kernelThreadsMax", 99999),
                    Map.entry("netCoreWmemDefault", 12345),
                    Map.entry("netIpv4IpLocalPortRange", "20000 60000"),
                    Map.entry("netIpv4TcpTwReuse", true)
                )),
                Map.entry("transparentHugePageDefrag", "madvise"),
                Map.entry("transparentHugePageEnabled", "always")
            ))
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_ND96asr_v4")
            .build());
    }
}
Content copied to clipboard

Create Agent Pool with KubeletConfig and LinuxOSConfig

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        KubeletConfig = new AzureNative.ContainerService.Inputs.KubeletConfigArgs
        {
            AllowedUnsafeSysctls = new[]
            {
                "kernel.msg*",
                "net.core.somaxconn",
            },
            CpuCfsQuota = true,
            CpuCfsQuotaPeriod = "200ms",
            CpuManagerPolicy = "static",
            FailSwapOn = false,
            ImageGcHighThreshold = 90,
            ImageGcLowThreshold = 70,
            TopologyManagerPolicy = "best-effort",
        },
        LinuxOSConfig = new AzureNative.ContainerService.Inputs.LinuxOSConfigArgs
        {
            SwapFileSizeMB = 1500,
            Sysctls = new AzureNative.ContainerService.Inputs.SysctlConfigArgs
            {
                KernelThreadsMax = 99999,
                NetCoreWmemDefault = 12345,
                NetIpv4IpLocalPortRange = "20000 60000",
                NetIpv4TcpTwReuse = true,
            },
            TransparentHugePageDefrag = "madvise",
            TransparentHugePageEnabled = "always",
        },
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_DS2_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName: pulumi.String("agentpool1"),
			Count:         pulumi.Int(3),
			KubeletConfig: &containerservice.KubeletConfigArgs{
				AllowedUnsafeSysctls: pulumi.StringArray{
					pulumi.String("kernel.msg*"),
					pulumi.String("net.core.somaxconn"),
				},
				CpuCfsQuota:           pulumi.Bool(true),
				CpuCfsQuotaPeriod:     pulumi.String("200ms"),
				CpuManagerPolicy:      pulumi.String("static"),
				FailSwapOn:            pulumi.Bool(false),
				ImageGcHighThreshold:  pulumi.Int(90),
				ImageGcLowThreshold:   pulumi.Int(70),
				TopologyManagerPolicy: pulumi.String("best-effort"),
			},
			LinuxOSConfig: containerservice.LinuxOSConfigResponse{
				SwapFileSizeMB: pulumi.Int(1500),
				Sysctls: &containerservice.SysctlConfigArgs{
					KernelThreadsMax:        pulumi.Int(99999),
					NetCoreWmemDefault:      pulumi.Int(12345),
					NetIpv4IpLocalPortRange: pulumi.String("20000 60000"),
					NetIpv4TcpTwReuse:       pulumi.Bool(true),
				},
				TransparentHugePageDefrag:  pulumi.String("madvise"),
				TransparentHugePageEnabled: pulumi.String("always"),
			},
			OrchestratorVersion: pulumi.String(""),
			OsType:              pulumi.String("Linux"),
			ResourceGroupName:   pulumi.String("rg1"),
			ResourceName:        pulumi.String("clustername1"),
			VmSize:              pulumi.String("Standard_DS2_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .kubeletConfig(Map.ofEntries(
                Map.entry("allowedUnsafeSysctls",
                    "kernel.msg*",
                    "net.core.somaxconn"),
                Map.entry("cpuCfsQuota", true),
                Map.entry("cpuCfsQuotaPeriod", "200ms"),
                Map.entry("cpuManagerPolicy", "static"),
                Map.entry("failSwapOn", false),
                Map.entry("imageGcHighThreshold", 90),
                Map.entry("imageGcLowThreshold", 70),
                Map.entry("topologyManagerPolicy", "best-effort")
            ))
            .linuxOSConfig(Map.ofEntries(
                Map.entry("swapFileSizeMB", 1500),
                Map.entry("sysctls", Map.ofEntries(
                    Map.entry("kernelThreadsMax", 99999),
                    Map.entry("netCoreWmemDefault", 12345),
                    Map.entry("netIpv4IpLocalPortRange", "20000 60000"),
                    Map.entry("netIpv4TcpTwReuse", true)
                )),
                Map.entry("transparentHugePageDefrag", "madvise"),
                Map.entry("transparentHugePageEnabled", "always")
            ))
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_DS2_v2")
            .build());
    }
}
Content copied to clipboard

Create Agent Pool with OSSKU

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        KubeletConfig = new AzureNative.ContainerService.Inputs.KubeletConfigArgs
        {
            AllowedUnsafeSysctls = new[]
            {
                "kernel.msg*",
                "net.core.somaxconn",
            },
            CpuCfsQuota = true,
            CpuCfsQuotaPeriod = "200ms",
            CpuManagerPolicy = "static",
            FailSwapOn = false,
            ImageGcHighThreshold = 90,
            ImageGcLowThreshold = 70,
            TopologyManagerPolicy = "best-effort",
        },
        LinuxOSConfig = new AzureNative.ContainerService.Inputs.LinuxOSConfigArgs
        {
            SwapFileSizeMB = 1500,
            Sysctls = new AzureNative.ContainerService.Inputs.SysctlConfigArgs
            {
                KernelThreadsMax = 99999,
                NetCoreWmemDefault = 12345,
                NetIpv4IpLocalPortRange = "20000 60000",
                NetIpv4TcpTwReuse = true,
            },
            TransparentHugePageDefrag = "madvise",
            TransparentHugePageEnabled = "always",
        },
        OrchestratorVersion = "",
        OsSKU = "CBLMariner",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_DS2_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName: pulumi.String("agentpool1"),
			Count:         pulumi.Int(3),
			KubeletConfig: &containerservice.KubeletConfigArgs{
				AllowedUnsafeSysctls: pulumi.StringArray{
					pulumi.String("kernel.msg*"),
					pulumi.String("net.core.somaxconn"),
				},
				CpuCfsQuota:           pulumi.Bool(true),
				CpuCfsQuotaPeriod:     pulumi.String("200ms"),
				CpuManagerPolicy:      pulumi.String("static"),
				FailSwapOn:            pulumi.Bool(false),
				ImageGcHighThreshold:  pulumi.Int(90),
				ImageGcLowThreshold:   pulumi.Int(70),
				TopologyManagerPolicy: pulumi.String("best-effort"),
			},
			LinuxOSConfig: containerservice.LinuxOSConfigResponse{
				SwapFileSizeMB: pulumi.Int(1500),
				Sysctls: &containerservice.SysctlConfigArgs{
					KernelThreadsMax:        pulumi.Int(99999),
					NetCoreWmemDefault:      pulumi.Int(12345),
					NetIpv4IpLocalPortRange: pulumi.String("20000 60000"),
					NetIpv4TcpTwReuse:       pulumi.Bool(true),
				},
				TransparentHugePageDefrag:  pulumi.String("madvise"),
				TransparentHugePageEnabled: pulumi.String("always"),
			},
			OrchestratorVersion: pulumi.String(""),
			OsSKU:               pulumi.String("CBLMariner"),
			OsType:              pulumi.String("Linux"),
			ResourceGroupName:   pulumi.String("rg1"),
			ResourceName:        pulumi.String("clustername1"),
			VmSize:              pulumi.String("Standard_DS2_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .kubeletConfig(Map.ofEntries(
                Map.entry("allowedUnsafeSysctls",
                    "kernel.msg*",
                    "net.core.somaxconn"),
                Map.entry("cpuCfsQuota", true),
                Map.entry("cpuCfsQuotaPeriod", "200ms"),
                Map.entry("cpuManagerPolicy", "static"),
                Map.entry("failSwapOn", false),
                Map.entry("imageGcHighThreshold", 90),
                Map.entry("imageGcLowThreshold", 70),
                Map.entry("topologyManagerPolicy", "best-effort")
            ))
            .linuxOSConfig(Map.ofEntries(
                Map.entry("swapFileSizeMB", 1500),
                Map.entry("sysctls", Map.ofEntries(
                    Map.entry("kernelThreadsMax", 99999),
                    Map.entry("netCoreWmemDefault", 12345),
                    Map.entry("netIpv4IpLocalPortRange", "20000 60000"),
                    Map.entry("netIpv4TcpTwReuse", true)
                )),
                Map.entry("transparentHugePageDefrag", "madvise"),
                Map.entry("transparentHugePageEnabled", "always")
            ))
            .orchestratorVersion("")
            .osSKU("CBLMariner")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_DS2_v2")
            .build());
    }
}
Content copied to clipboard

Create Agent Pool with PPG

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        OrchestratorVersion = "",
        OsType = "Linux",
        ProximityPlacementGroupID = "/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        VmSize = "Standard_DS2_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName:             pulumi.String("agentpool1"),
			Count:                     pulumi.Int(3),
			OrchestratorVersion:       pulumi.String(""),
			OsType:                    pulumi.String("Linux"),
			ProximityPlacementGroupID: pulumi.String("/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1"),
			ResourceGroupName:         pulumi.String("rg1"),
			ResourceName:              pulumi.String("clustername1"),
			VmSize:                    pulumi.String("Standard_DS2_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .orchestratorVersion("")
            .osType("Linux")
            .proximityPlacementGroupID("/subscriptions/subid1/resourcegroups/rg1/providers//Microsoft.Compute/proximityPlacementGroups/ppg1")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .vmSize("Standard_DS2_v2")
            .build());
    }
}
Content copied to clipboard

Create Spot Agent Pool

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        NodeLabels =
        {
            { "key1", "val1" },
        },
        NodeTaints = new[]
        {
            "Key1=Value1:NoSchedule",
        },
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ScaleSetEvictionPolicy = "Delete",
        ScaleSetPriority = "Spot",
        Tags =
        {
            { "name1", "val1" },
        },
        VmSize = "Standard_DS1_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName: pulumi.String("agentpool1"),
			Count:         pulumi.Int(3),
			NodeLabels: pulumi.StringMap{
				"key1": pulumi.String("val1"),
			},
			NodeTaints: pulumi.StringArray{
				pulumi.String("Key1=Value1:NoSchedule"),
			},
			OrchestratorVersion:    pulumi.String(""),
			OsType:                 pulumi.String("Linux"),
			ResourceGroupName:      pulumi.String("rg1"),
			ResourceName:           pulumi.String("clustername1"),
			ScaleSetEvictionPolicy: pulumi.String("Delete"),
			ScaleSetPriority:       pulumi.String("Spot"),
			Tags: pulumi.StringMap{
				"name1": pulumi.String("val1"),
			},
			VmSize: pulumi.String("Standard_DS1_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .nodeLabels(Map.of("key1", "val1"))
            .nodeTaints("Key1=Value1:NoSchedule")
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .scaleSetEvictionPolicy("Delete")
            .scaleSetPriority("Spot")
            .tags(Map.of("name1", "val1"))
            .vmSize("Standard_DS1_v2")
            .build());
    }
}
Content copied to clipboard

Create/Update Agent Pool

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        Mode = "User",
        NodeLabels =
        {
            { "key1", "val1" },
        },
        NodeTaints = new[]
        {
            "Key1=Value1:NoSchedule",
        },
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ScaleSetEvictionPolicy = "Delete",
        ScaleSetPriority = "Spot",
        Tags =
        {
            { "name1", "val1" },
        },
        VmSize = "Standard_DS1_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName: pulumi.String("agentpool1"),
			Count:         pulumi.Int(3),
			Mode:          pulumi.String("User"),
			NodeLabels: pulumi.StringMap{
				"key1": pulumi.String("val1"),
			},
			NodeTaints: pulumi.StringArray{
				pulumi.String("Key1=Value1:NoSchedule"),
			},
			OrchestratorVersion:    pulumi.String(""),
			OsType:                 pulumi.String("Linux"),
			ResourceGroupName:      pulumi.String("rg1"),
			ResourceName:           pulumi.String("clustername1"),
			ScaleSetEvictionPolicy: pulumi.String("Delete"),
			ScaleSetPriority:       pulumi.String("Spot"),
			Tags: pulumi.StringMap{
				"name1": pulumi.String("val1"),
			},
			VmSize: pulumi.String("Standard_DS1_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .mode("User")
            .nodeLabels(Map.of("key1", "val1"))
            .nodeTaints("Key1=Value1:NoSchedule")
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .scaleSetEvictionPolicy("Delete")
            .scaleSetPriority("Spot")
            .tags(Map.of("name1", "val1"))
            .vmSize("Standard_DS1_v2")
            .build());
    }
}
Content copied to clipboard

Update Agent Pool

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var agentPool = new AzureNative.ContainerService.AgentPool("agentPool", new()
    {
        AgentPoolName = "agentpool1",
        Count = 3,
        EnableAutoScaling = true,
        MaxCount = 2,
        MinCount = 2,
        NodeTaints = new[]
        {
            "Key1=Value1:NoSchedule",
        },
        OrchestratorVersion = "",
        OsType = "Linux",
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
        ScaleSetEvictionPolicy = "Delete",
        ScaleSetPriority = "Spot",
        VmSize = "Standard_DS1_v2",
    });
});
Content copied to clipboard
package main
import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewAgentPool(ctx, "agentPool", &containerservice.AgentPoolArgs{
			AgentPoolName:     pulumi.String("agentpool1"),
			Count:             pulumi.Int(3),
			EnableAutoScaling: pulumi.Bool(true),
			MaxCount:          pulumi.Int(2),
			MinCount:          pulumi.Int(2),
			NodeTaints: pulumi.StringArray{
				pulumi.String("Key1=Value1:NoSchedule"),
			},
			OrchestratorVersion:    pulumi.String(""),
			OsType:                 pulumi.String("Linux"),
			ResourceGroupName:      pulumi.String("rg1"),
			ResourceName:           pulumi.String("clustername1"),
			ScaleSetEvictionPolicy: pulumi.String("Delete"),
			ScaleSetPriority:       pulumi.String("Spot"),
			VmSize:                 pulumi.String("Standard_DS1_v2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerservice.AgentPool;
import com.pulumi.azurenative.containerservice.AgentPoolArgs;
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 agentPool = new AgentPool("agentPool", AgentPoolArgs.builder()
            .agentPoolName("agentpool1")
            .count(3)
            .enableAutoScaling(true)
            .maxCount(2)
            .minCount(2)
            .nodeTaints("Key1=Value1:NoSchedule")
            .orchestratorVersion("")
            .osType("Linux")
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .scaleSetEvictionPolicy("Delete")
            .scaleSetPriority("Spot")
            .vmSize("Standard_DS1_v2")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:containerservice:AgentPool agentpool1 /subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(agentPoolName: Output<String>? = null, availabilityZones: Output<List<String>>? = null, count: Output<Int>? = null, enableAutoScaling: Output<Boolean>? = null, enableEncryptionAtHost: Output<Boolean>? = null, enableFIPS: Output<Boolean>? = null, enableNodePublicIP: Output<Boolean>? = null, gpuInstanceProfile: Output<Either<String, GPUInstanceProfile>>? = null, kubeletConfig: Output<KubeletConfigArgs>? = null, kubeletDiskType: Output<Either<String, KubeletDiskType>>? = null, linuxOSConfig: Output<LinuxOSConfigArgs>? = null, maxCount: Output<Int>? = null, maxPods: Output<Int>? = null, minCount: Output<Int>? = null, mode: Output<Either<String, AgentPoolMode>>? = null, nodeLabels: Output<Map<String, String>>? = null, nodePublicIPPrefixID: Output<String>? = null, nodeTaints: Output<List<String>>? = null, orchestratorVersion: Output<String>? = null, osDiskSizeGB: Output<Int>? = null, osDiskType: Output<Either<String, OSDiskType>>? = null, osSKU: Output<Either<String, OSSKU>>? = null, osType: Output<Either<String, OSType>>? = null, podSubnetID: Output<String>? = null, proximityPlacementGroupID: Output<String>? = null, resourceGroupName: Output<String>? = null, resourceName: Output<String>? = null, scaleSetEvictionPolicy: Output<Either<String, ScaleSetEvictionPolicy>>? = null, scaleSetPriority: Output<Either<String, ScaleSetPriority>>? = null, spotMaxPrice: Output<Double>? = null, tags: Output<Map<String, String>>? = null, type: Output<Either<String, AgentPoolType>>? = null, upgradeSettings: Output<AgentPoolUpgradeSettingsArgs>? = null, vmSize: Output<String>? = null, vnetSubnetID: Output<String>? = null)

Properties

Link copied to clipboard
val agentPoolName: Output<String>? = null

The name of the agent pool.

Link copied to clipboard
val availabilityZones: Output<List<String>>? = null

Availability zones for nodes. Must use VirtualMachineScaleSets AgentPoolType.

Link copied to clipboard
val count: Output<Int>? = null

Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 100 (inclusive) for user pools and in the range of 1 to 100 (inclusive) for system pools. The default value is 1.

Link copied to clipboard
val enableAutoScaling: Output<Boolean>? = null

Whether to enable auto-scaler

Link copied to clipboard
val enableEncryptionAtHost: Output<Boolean>? = null

Whether to enable EncryptionAtHost

Link copied to clipboard
val enableFIPS: Output<Boolean>? = null

Whether to use FIPS enabled OS

Link copied to clipboard
val enableNodePublicIP: Output<Boolean>? = null

Enable public IP for nodes

Link copied to clipboard
val gpuInstanceProfile: Output<Either<String, GPUInstanceProfile>>? = null

GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. Supported values are MIG1g, MIG2g, MIG3g, MIG4g and MIG7g.

Link copied to clipboard
val kubeletConfig: Output<KubeletConfigArgs>? = null

KubeletConfig specifies the configuration of kubelet on agent nodes.

Link copied to clipboard
val kubeletDiskType: Output<Either<String, KubeletDiskType>>? = null

KubeletDiskType determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. Currently allows one value, OS, resulting in Kubelet using the OS disk for data.

Link copied to clipboard
val linuxOSConfig: Output<LinuxOSConfigArgs>? = null

LinuxOSConfig specifies the OS configuration of linux agent nodes.

Link copied to clipboard
val maxCount: Output<Int>? = null

Maximum number of nodes for auto-scaling

Link copied to clipboard
val maxPods: Output<Int>? = null

Maximum number of pods that can run on a node.

Link copied to clipboard
val minCount: Output<Int>? = null

Minimum number of nodes for auto-scaling

Link copied to clipboard
val mode: Output<Either<String, AgentPoolMode>>? = null

AgentPoolMode represents mode of an agent pool

Link copied to clipboard
val nodeLabels: Output<Map<String, String>>? = null

Agent pool node labels to be persisted across all nodes in agent pool.

Link copied to clipboard
val nodePublicIPPrefixID: Output<String>? = null

Public IP Prefix ID. VM nodes use IPs assigned from this Public IP Prefix.

Link copied to clipboard
val nodeTaints: Output<List<String>>? = null

Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.

Link copied to clipboard
val orchestratorVersion: Output<String>? = null

Version of orchestrator specified when creating the managed cluster.

Link copied to clipboard
val osDiskSizeGB: Output<Int>? = null

OS Disk Size in GB to be used to specify the disk size for every machine in this master/agent pool. If you specify 0, it will apply the default osDisk size according to the vmSize specified.

Link copied to clipboard
val osDiskType: Output<Either<String, OSDiskType>>? = null

OS disk type to be used for machines in a given agent pool. Allowed values are 'Ephemeral' and 'Managed'. If unspecified, defaults to 'Ephemeral' when the VM supports ephemeral OS and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to 'Managed'. May not be changed after creation.

Link copied to clipboard
val osSKU: Output<Either<String, OSSKU>>? = null

OsSKU to be used to specify os sku. Choose from Ubuntu(default) and CBLMariner for Linux OSType. Not applicable to Windows OSType.

Link copied to clipboard
val osType: Output<Either<String, OSType>>? = null

OsType to be used to specify os type. Choose from Linux and Windows. Default to Linux.

Link copied to clipboard
val podSubnetID: Output<String>? = null

Pod SubnetID specifies the VNet's subnet identifier for pods.

Link copied to clipboard
val proximityPlacementGroupID: Output<String>? = null

The ID for Proximity Placement Group.

Link copied to clipboard
val resourceGroupName: Output<String>? = null

The name of the resource group.

Link copied to clipboard
val resourceName: Output<String>? = null

The name of the managed cluster resource.

Link copied to clipboard
val scaleSetEvictionPolicy: Output<Either<String, ScaleSetEvictionPolicy>>? = null

ScaleSetEvictionPolicy to be used to specify eviction policy for Spot virtual machine scale set. Default to Delete.

Link copied to clipboard
val scaleSetPriority: Output<Either<String, ScaleSetPriority>>? = null

ScaleSetPriority to be used to specify virtual machine scale set priority. Default to regular.

Link copied to clipboard
val spotMaxPrice: Output<Double>? = null

SpotMaxPrice to be used to specify the maximum price you are willing to pay in US Dollars. Possible values are any decimal value greater than zero or -1 which indicates default price to be up-to on-demand.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Agent pool tags to be persisted on the agent pool virtual machine scale set.

Link copied to clipboard
val type: Output<Either<String, AgentPoolType>>? = null

AgentPoolType represents types of an agent pool

Link copied to clipboard
val upgradeSettings: Output<AgentPoolUpgradeSettingsArgs>? = null

Settings for upgrading the agentpool

Link copied to clipboard
val vmSize: Output<String>? = null

Size of agent VMs.

Link copied to clipboard
val vnetSubnetID: Output<String>? = null

VNet SubnetID specifies the VNet's subnet identifier for nodes and maybe pods

Functions

Link copied to clipboard
open override fun toJava(): AgentPoolArgs