pulumi-azure-native-kotlin/com.pulumi.azurenative.servicefabric.kotlin/NodeType

NodeType

class NodeType : KotlinCustomResource

Describes a node type in the cluster, each node type represents sub set of nodes in the cluster. API Version: 2020-01-01-preview.

Example Usage

Put a node type with maximum parameters

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var nodeType = new AzureNative.ServiceFabric.NodeType("nodeType", new()
    {
        Capacities =
        {
            { "ClientConnections", "65536" },
        },
        ClusterName = "myCluster",
        DataDiskSizeGB = 200,
        IsPrimary = false,
        NodeTypeName = "BE",
        PlacementProperties =
        {
            { "HasSSD", "true" },
            { "NodeColor", "green" },
            { "SomeProperty", "5" },
        },
        ResourceGroupName = "resRg",
        VmExtensions = new[]
        {
            new AzureNative.ServiceFabric.Inputs.VMSSExtensionArgs
            {
                AutoUpgradeMinorVersion = true,
                Name = "Microsoft.Azure.Geneva.GenevaMonitoring",
                Publisher = "Microsoft.Azure.Geneva",
                Settings = null,
                Type = "GenevaMonitoring",
                TypeHandlerVersion = "2.0",
            },
        },
        VmImageOffer = "WindowsServer",
        VmImagePublisher = "MicrosoftWindowsServer",
        VmImageSku = "2016-Datacenter-Server-Core",
        VmImageVersion = "latest",
        VmInstanceCount = 10,
        VmSecrets = new[]
        {
            new AzureNative.ServiceFabric.Inputs.VaultSecretGroupArgs
            {
                SourceVault = new AzureNative.ServiceFabric.Inputs.SubResourceArgs
                {
                    Id = "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.KeyVault/vaults/myVault",
                },
                VaultCertificates = new[]
                {
                    new AzureNative.ServiceFabric.Inputs.VaultCertificateArgs
                    {
                        CertificateStore = "My",
                        CertificateUrl = "https://myVault.vault.azure.net:443/secrets/myCert/ef1a31d39e1f46bca33def54b6cda54c",
                    },
                },
            },
        },
        VmSize = "Standard_D3",
    });
});
Content copied to clipboard
package main
import (
	servicefabric "github.com/pulumi/pulumi-azure-native-sdk/servicefabric"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := servicefabric.NewNodeType(ctx, "nodeType", &servicefabric.NodeTypeArgs{
			Capacities: pulumi.StringMap{
				"ClientConnections": pulumi.String("65536"),
			},
			ClusterName:    pulumi.String("myCluster"),
			DataDiskSizeGB: pulumi.Int(200),
			IsPrimary:      pulumi.Bool(false),
			NodeTypeName:   pulumi.String("BE"),
			PlacementProperties: pulumi.StringMap{
				"HasSSD":       pulumi.String("true"),
				"NodeColor":    pulumi.String("green"),
				"SomeProperty": pulumi.String("5"),
			},
			ResourceGroupName: pulumi.String("resRg"),
			VmExtensions: []servicefabric.VMSSExtensionArgs{
				{
					AutoUpgradeMinorVersion: pulumi.Bool(true),
					Name:                    pulumi.String("Microsoft.Azure.Geneva.GenevaMonitoring"),
					Publisher:               pulumi.String("Microsoft.Azure.Geneva"),
					Settings:                nil,
					Type:                    pulumi.String("GenevaMonitoring"),
					TypeHandlerVersion:      pulumi.String("2.0"),
				},
			},
			VmImageOffer:     pulumi.String("WindowsServer"),
			VmImagePublisher: pulumi.String("MicrosoftWindowsServer"),
			VmImageSku:       pulumi.String("2016-Datacenter-Server-Core"),
			VmImageVersion:   pulumi.String("latest"),
			VmInstanceCount:  pulumi.Int(10),
			VmSecrets: []servicefabric.VaultSecretGroupArgs{
				{
					SourceVault: {
						Id: pulumi.String("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.KeyVault/vaults/myVault"),
					},
					VaultCertificates: servicefabric.VaultCertificateArray{
						{
							CertificateStore: pulumi.String("My"),
							CertificateUrl:   pulumi.String("https://myVault.vault.azure.net:443/secrets/myCert/ef1a31d39e1f46bca33def54b6cda54c"),
						},
					},
				},
			},
			VmSize: pulumi.String("Standard_D3"),
		})
		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.servicefabric.NodeType;
import com.pulumi.azurenative.servicefabric.NodeTypeArgs;
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 nodeType = new NodeType("nodeType", NodeTypeArgs.builder()
            .capacities(Map.of("ClientConnections", "65536"))
            .clusterName("myCluster")
            .dataDiskSizeGB(200)
            .isPrimary(false)
            .nodeTypeName("BE")
            .placementProperties(Map.ofEntries(
                Map.entry("HasSSD", "true"),
                Map.entry("NodeColor", "green"),
                Map.entry("SomeProperty", "5")
            ))
            .resourceGroupName("resRg")
            .vmExtensions(Map.ofEntries(
                Map.entry("autoUpgradeMinorVersion", true),
                Map.entry("name", "Microsoft.Azure.Geneva.GenevaMonitoring"),
                Map.entry("publisher", "Microsoft.Azure.Geneva"),
                Map.entry("settings", ),
                Map.entry("type", "GenevaMonitoring"),
                Map.entry("typeHandlerVersion", "2.0")
            ))
            .vmImageOffer("WindowsServer")
            .vmImagePublisher("MicrosoftWindowsServer")
            .vmImageSku("2016-Datacenter-Server-Core")
            .vmImageVersion("latest")
            .vmInstanceCount(10)
            .vmSecrets(Map.ofEntries(
                Map.entry("sourceVault", Map.of("id", "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.KeyVault/vaults/myVault")),
                Map.entry("vaultCertificates", Map.ofEntries(
                    Map.entry("certificateStore", "My"),
                    Map.entry("certificateUrl", "https://myVault.vault.azure.net:443/secrets/myCert/ef1a31d39e1f46bca33def54b6cda54c")
                ))
            ))
            .vmSize("Standard_D3")
            .build());
    }
}
Content copied to clipboard

Put a node type with minimum parameters

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var nodeType = new AzureNative.ServiceFabric.NodeType("nodeType", new()
    {
        ClusterName = "myCluster",
        DataDiskSizeGB = 200,
        IsPrimary = false,
        NodeTypeName = "BE",
        ResourceGroupName = "resRg",
        VmImageOffer = "WindowsServer",
        VmImagePublisher = "MicrosoftWindowsServer",
        VmImageSku = "2016-Datacenter-Server-Core",
        VmImageVersion = "latest",
        VmInstanceCount = 10,
        VmSize = "Standard_D3",
    });
});
Content copied to clipboard
package main
import (
	servicefabric "github.com/pulumi/pulumi-azure-native-sdk/servicefabric"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := servicefabric.NewNodeType(ctx, "nodeType", &servicefabric.NodeTypeArgs{
			ClusterName:       pulumi.String("myCluster"),
			DataDiskSizeGB:    pulumi.Int(200),
			IsPrimary:         pulumi.Bool(false),
			NodeTypeName:      pulumi.String("BE"),
			ResourceGroupName: pulumi.String("resRg"),
			VmImageOffer:      pulumi.String("WindowsServer"),
			VmImagePublisher:  pulumi.String("MicrosoftWindowsServer"),
			VmImageSku:        pulumi.String("2016-Datacenter-Server-Core"),
			VmImageVersion:    pulumi.String("latest"),
			VmInstanceCount:   pulumi.Int(10),
			VmSize:            pulumi.String("Standard_D3"),
		})
		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.servicefabric.NodeType;
import com.pulumi.azurenative.servicefabric.NodeTypeArgs;
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 nodeType = new NodeType("nodeType", NodeTypeArgs.builder()
            .clusterName("myCluster")
            .dataDiskSizeGB(200)
            .isPrimary(false)
            .nodeTypeName("BE")
            .resourceGroupName("resRg")
            .vmImageOffer("WindowsServer")
            .vmImagePublisher("MicrosoftWindowsServer")
            .vmImageSku("2016-Datacenter-Server-Core")
            .vmImageVersion("latest")
            .vmInstanceCount(10)
            .vmSize("Standard_D3")
            .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:servicefabric:NodeType BE /subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.ServiceFabric/managedClusters/myCluster/nodeTypes/BE
Content copied to clipboard

Properties

Link copied to clipboard
val applicationPorts: Output<EndpointRangeDescriptionResponse>?

The range of ports from which cluster assigned port to Service Fabric applications.

Link copied to clipboard
val capacities: Output<Map<String, String>>?

The capacity tags applied to the nodes in the node type, the cluster resource manager uses these tags to understand how much resource a node has.

Link copied to clipboard
val dataDiskSizeGB: Output<Int>

Disk size for each vm in the node type in GBs.

Link copied to clipboard
val ephemeralPorts: Output<EndpointRangeDescriptionResponse>?

The range of ephemeral ports that nodes in this node type should be configured with.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val isPrimary: Output<Boolean>

The node type on which system services will run. Only one node type should be marked as primary. Primary node type cannot be deleted or changed for existing clusters.

Link copied to clipboard
val name: Output<String>

Azure resource name.

Link copied to clipboard
val placementProperties: Output<Map<String, String>>?

The placement tags applied to nodes in the node type, which can be used to indicate where certain services (workload) should run.

Link copied to clipboard
val provisioningState: Output<String>

The provisioning state of the managed cluster resource.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val tags: Output<Map<String, String>>?

Azure resource tags.

Link copied to clipboard
val type: Output<String>

Azure resource type.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val vmExtensions: Output<List<VMSSExtensionResponse>>?

Set of extensions that should be installed onto the virtual machines.

Link copied to clipboard
val vmImageOffer: Output<String>?

The offer type of the Azure Virtual Machines Marketplace image. For example, UbuntuServer or WindowsServer.

Link copied to clipboard
val vmImagePublisher: Output<String>?

The publisher of the Azure Virtual Machines Marketplace image. For example, Canonical or MicrosoftWindowsServer.

Link copied to clipboard
val vmImageSku: Output<String>?

The SKU of the Azure Virtual Machines Marketplace image. For example, 14.04.0-LTS or 2012-R2-Datacenter.

Link copied to clipboard
val vmImageVersion: Output<String>?

The version of the Azure Virtual Machines Marketplace image. A value of 'latest' can be specified to select the latest version of an image. If omitted, the default is 'latest'.

Link copied to clipboard
val vmInstanceCount: Output<Int>

The number of nodes in the node type.

Link copied to clipboard
val vmSecrets: Output<List<VaultSecretGroupResponse>>?

The secrets to install in the virtual machines.

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

The size of virtual machines in the pool. All virtual machines in a pool are the same size. For example, Standard_D3.