spotinst logo
Spotinst v3.35.0, Jun 1 23

spotinst.gcp.Elastigroup

Explore with Pulumi AI

Provides a Spotinst elastigroup GCP resource.

Example Usage

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

return await Deployment.RunAsync(() => 
{
    var example = new SpotInst.Gcp.Elastigroup("example", new()
    {
        AvailabilityZones = new[]
        {
            "asia-east1-c",
            "us-central1-a",
        },
        BackendServices = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupBackendServiceArgs
            {
                LocationType = "regional",
                NamedPorts = new[]
                {
                    new SpotInst.Gcp.Inputs.ElastigroupBackendServiceNamedPortArgs
                    {
                        Name = "port-name",
                        Ports = new[]
                        {
                            "8000",
                            "6000",
                        },
                    },
                },
                Scheme = "INTERNAL",
                ServiceName = "spotinst-elb-backend-service",
            },
        },
        Description = "spotinst gcp group",
        DesiredCapacity = 1,
        Disks = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupDiskArgs
            {
                AutoDelete = true,
                Boot = true,
                DeviceName = "device",
                InitializeParams = new[]
                {
                    new SpotInst.Gcp.Inputs.ElastigroupDiskInitializeParamArgs
                    {
                        DiskSizeGb = "10",
                        DiskType = "pd-standard",
                        SourceImage = "",
                    },
                },
                Interface = "SCSI",
                Mode = "READ_WRITE",
                Type = "PERSISTENT",
            },
        },
        DrainingTimeout = 180,
        FallbackToOndemand = true,
        InstanceNamePrefix = "test-123a",
        InstanceTypesCustoms = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupInstanceTypesCustomArgs
            {
                MemoryGib = 7,
                Vcpu = 2,
            },
        },
        InstanceTypesOndemand = "n1-standard-1",
        InstanceTypesPreemptibles = new[]
        {
            "n1-standard-1",
            "n1-standard-2",
        },
        Labels = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupLabelArgs
            {
                Key = "test_key",
                Value = "test_value",
            },
        },
        MaxSize = 1,
        MinSize = 0,
        NetworkInterfaces = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupNetworkInterfaceArgs
            {
                Network = "spot-network",
            },
        },
        PreemptiblePercentage = 50,
        ProvisioningModel = "SPOT",
        ScalingUpPolicies = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupScalingUpPolicyArgs
            {
                ActionType = "adjustment",
                Adjustment = 1,
                Cooldown = 300,
                Dimensions = new[]
                {
                    new SpotInst.Gcp.Inputs.ElastigroupScalingUpPolicyDimensionArgs
                    {
                        Name = "storage_type",
                        Value = "pd-ssd",
                    },
                },
                EvaluationPeriods = 1,
                MetricName = "instance/disk/read_ops_count",
                Namespace = "compute",
                Operator = "gte",
                Period = 300,
                PolicyName = "scale_up_1",
                Source = "stackdriver",
                Statistic = "average",
                Threshold = 10000,
                Unit = "percent",
            },
        },
        ServiceAccount = "example@myProject.iam.gservicecct.com",
        StartupScript = "",
        Subnets = new[]
        {
            new SpotInst.Gcp.Inputs.ElastigroupSubnetArgs
            {
                Region = "asia-east1",
                SubnetNames = new[]
                {
                    "default",
                },
            },
        },
        Tags = new[]
        {
            "http",
            "https",
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-spotinst/sdk/v3/go/spotinst/gcp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gcp.NewElastigroup(ctx, "example", &gcp.ElastigroupArgs{
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("asia-east1-c"),
				pulumi.String("us-central1-a"),
			},
			BackendServices: gcp.ElastigroupBackendServiceArray{
				&gcp.ElastigroupBackendServiceArgs{
					LocationType: pulumi.String("regional"),
					NamedPorts: gcp.ElastigroupBackendServiceNamedPortArray{
						&gcp.ElastigroupBackendServiceNamedPortArgs{
							Name: pulumi.String("port-name"),
							Ports: pulumi.StringArray{
								pulumi.String("8000"),
								pulumi.String("6000"),
							},
						},
					},
					Scheme:      pulumi.String("INTERNAL"),
					ServiceName: pulumi.String("spotinst-elb-backend-service"),
				},
			},
			Description:     pulumi.String("spotinst gcp group"),
			DesiredCapacity: pulumi.Int(1),
			Disks: gcp.ElastigroupDiskArray{
				&gcp.ElastigroupDiskArgs{
					AutoDelete: pulumi.Bool(true),
					Boot:       pulumi.Bool(true),
					DeviceName: pulumi.String("device"),
					InitializeParams: gcp.ElastigroupDiskInitializeParamArray{
						&gcp.ElastigroupDiskInitializeParamArgs{
							DiskSizeGb:  pulumi.String("10"),
							DiskType:    pulumi.String("pd-standard"),
							SourceImage: pulumi.String(""),
						},
					},
					Interface: pulumi.String("SCSI"),
					Mode:      pulumi.String("READ_WRITE"),
					Type:      pulumi.String("PERSISTENT"),
				},
			},
			DrainingTimeout:    pulumi.Int(180),
			FallbackToOndemand: pulumi.Bool(true),
			InstanceNamePrefix: pulumi.String("test-123a"),
			InstanceTypesCustoms: gcp.ElastigroupInstanceTypesCustomArray{
				&gcp.ElastigroupInstanceTypesCustomArgs{
					MemoryGib: pulumi.Int(7),
					Vcpu:      pulumi.Int(2),
				},
			},
			InstanceTypesOndemand: pulumi.String("n1-standard-1"),
			InstanceTypesPreemptibles: pulumi.StringArray{
				pulumi.String("n1-standard-1"),
				pulumi.String("n1-standard-2"),
			},
			Labels: gcp.ElastigroupLabelArray{
				&gcp.ElastigroupLabelArgs{
					Key:   pulumi.String("test_key"),
					Value: pulumi.String("test_value"),
				},
			},
			MaxSize: pulumi.Int(1),
			MinSize: pulumi.Int(0),
			NetworkInterfaces: gcp.ElastigroupNetworkInterfaceArray{
				&gcp.ElastigroupNetworkInterfaceArgs{
					Network: pulumi.String("spot-network"),
				},
			},
			PreemptiblePercentage: pulumi.Int(50),
			ProvisioningModel:     pulumi.String("SPOT"),
			ScalingUpPolicies: gcp.ElastigroupScalingUpPolicyArray{
				&gcp.ElastigroupScalingUpPolicyArgs{
					ActionType: pulumi.String("adjustment"),
					Adjustment: pulumi.Int(1),
					Cooldown:   pulumi.Int(300),
					Dimensions: gcp.ElastigroupScalingUpPolicyDimensionArray{
						&gcp.ElastigroupScalingUpPolicyDimensionArgs{
							Name:  pulumi.String("storage_type"),
							Value: pulumi.String("pd-ssd"),
						},
					},
					EvaluationPeriods: pulumi.Int(1),
					MetricName:        pulumi.String("instance/disk/read_ops_count"),
					Namespace:         pulumi.String("compute"),
					Operator:          pulumi.String("gte"),
					Period:            pulumi.Int(300),
					PolicyName:        pulumi.String("scale_up_1"),
					Source:            pulumi.String("stackdriver"),
					Statistic:         pulumi.String("average"),
					Threshold:         pulumi.Float64(10000),
					Unit:              pulumi.String("percent"),
				},
			},
			ServiceAccount: pulumi.String("example@myProject.iam.gservicecct.com"),
			StartupScript:  pulumi.String(""),
			Subnets: gcp.ElastigroupSubnetArray{
				&gcp.ElastigroupSubnetArgs{
					Region: pulumi.String("asia-east1"),
					SubnetNames: pulumi.StringArray{
						pulumi.String("default"),
					},
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("http"),
				pulumi.String("https"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.spotinst.gcp.Elastigroup;
import com.pulumi.spotinst.gcp.ElastigroupArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupBackendServiceArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupDiskArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupInstanceTypesCustomArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupLabelArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupNetworkInterfaceArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupScalingUpPolicyArgs;
import com.pulumi.spotinst.gcp.inputs.ElastigroupSubnetArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Elastigroup("example", ElastigroupArgs.builder()        
            .availabilityZones(            
                "asia-east1-c",
                "us-central1-a")
            .backendServices(ElastigroupBackendServiceArgs.builder()
                .locationType("regional")
                .namedPorts(ElastigroupBackendServiceNamedPortArgs.builder()
                    .name("port-name")
                    .ports(                    
                        8000,
                        6000)
                    .build())
                .scheme("INTERNAL")
                .serviceName("spotinst-elb-backend-service")
                .build())
            .description("spotinst gcp group")
            .desiredCapacity(1)
            .disks(ElastigroupDiskArgs.builder()
                .autoDelete(true)
                .boot(true)
                .deviceName("device")
                .initializeParams(ElastigroupDiskInitializeParamArgs.builder()
                    .diskSizeGb(10)
                    .diskType("pd-standard")
                    .sourceImage("")
                    .build())
                .interface_("SCSI")
                .mode("READ_WRITE")
                .type("PERSISTENT")
                .build())
            .drainingTimeout(180)
            .fallbackToOndemand(true)
            .instanceNamePrefix("test-123a")
            .instanceTypesCustoms(ElastigroupInstanceTypesCustomArgs.builder()
                .memoryGib(7)
                .vcpu(2)
                .build())
            .instanceTypesOndemand("n1-standard-1")
            .instanceTypesPreemptibles(            
                "n1-standard-1",
                "n1-standard-2")
            .labels(ElastigroupLabelArgs.builder()
                .key("test_key")
                .value("test_value")
                .build())
            .maxSize(1)
            .minSize(0)
            .networkInterfaces(ElastigroupNetworkInterfaceArgs.builder()
                .network("spot-network")
                .build())
            .preemptiblePercentage(50)
            .provisioningModel("SPOT")
            .scalingUpPolicies(ElastigroupScalingUpPolicyArgs.builder()
                .actionType("adjustment")
                .adjustment(1)
                .cooldown(300)
                .dimensions(ElastigroupScalingUpPolicyDimensionArgs.builder()
                    .name("storage_type")
                    .value("pd-ssd")
                    .build())
                .evaluationPeriods(1)
                .metricName("instance/disk/read_ops_count")
                .namespace("compute")
                .operator("gte")
                .period(300)
                .policyName("scale_up_1")
                .source("stackdriver")
                .statistic("average")
                .threshold(10000)
                .unit("percent")
                .build())
            .serviceAccount("example@myProject.iam.gservicecct.com")
            .startupScript("")
            .subnets(ElastigroupSubnetArgs.builder()
                .region("asia-east1")
                .subnetNames("default")
                .build())
            .tags(            
                "http",
                "https")
            .build());

    }
}
import pulumi
import pulumi_spotinst as spotinst

example = spotinst.gcp.Elastigroup("example",
    availability_zones=[
        "asia-east1-c",
        "us-central1-a",
    ],
    backend_services=[spotinst.gcp.ElastigroupBackendServiceArgs(
        location_type="regional",
        named_ports=[spotinst.gcp.ElastigroupBackendServiceNamedPortArgs(
            name="port-name",
            ports=[
                "8000",
                "6000",
            ],
        )],
        scheme="INTERNAL",
        service_name="spotinst-elb-backend-service",
    )],
    description="spotinst gcp group",
    desired_capacity=1,
    disks=[spotinst.gcp.ElastigroupDiskArgs(
        auto_delete=True,
        boot=True,
        device_name="device",
        initialize_params=[spotinst.gcp.ElastigroupDiskInitializeParamArgs(
            disk_size_gb="10",
            disk_type="pd-standard",
            source_image="",
        )],
        interface="SCSI",
        mode="READ_WRITE",
        type="PERSISTENT",
    )],
    draining_timeout=180,
    fallback_to_ondemand=True,
    instance_name_prefix="test-123a",
    instance_types_customs=[spotinst.gcp.ElastigroupInstanceTypesCustomArgs(
        memory_gib=7,
        vcpu=2,
    )],
    instance_types_ondemand="n1-standard-1",
    instance_types_preemptibles=[
        "n1-standard-1",
        "n1-standard-2",
    ],
    labels=[spotinst.gcp.ElastigroupLabelArgs(
        key="test_key",
        value="test_value",
    )],
    max_size=1,
    min_size=0,
    network_interfaces=[spotinst.gcp.ElastigroupNetworkInterfaceArgs(
        network="spot-network",
    )],
    preemptible_percentage=50,
    provisioning_model="SPOT",
    scaling_up_policies=[spotinst.gcp.ElastigroupScalingUpPolicyArgs(
        action_type="adjustment",
        adjustment=1,
        cooldown=300,
        dimensions=[spotinst.gcp.ElastigroupScalingUpPolicyDimensionArgs(
            name="storage_type",
            value="pd-ssd",
        )],
        evaluation_periods=1,
        metric_name="instance/disk/read_ops_count",
        namespace="compute",
        operator="gte",
        period=300,
        policy_name="scale_up_1",
        source="stackdriver",
        statistic="average",
        threshold=10000,
        unit="percent",
    )],
    service_account="example@myProject.iam.gservicecct.com",
    startup_script="",
    subnets=[spotinst.gcp.ElastigroupSubnetArgs(
        region="asia-east1",
        subnet_names=["default"],
    )],
    tags=[
        "http",
        "https",
    ])
import * as pulumi from "@pulumi/pulumi";
import * as spotinst from "@pulumi/spotinst";

const example = new spotinst.gcp.Elastigroup("example", {
    availabilityZones: [
        "asia-east1-c",
        "us-central1-a",
    ],
    backendServices: [{
        locationType: "regional",
        namedPorts: [{
            name: "port-name",
            ports: [
                "8000",
                "6000",
            ],
        }],
        scheme: "INTERNAL",
        serviceName: "spotinst-elb-backend-service",
    }],
    description: "spotinst gcp group",
    desiredCapacity: 1,
    disks: [{
        autoDelete: true,
        boot: true,
        deviceName: "device",
        initializeParams: [{
            diskSizeGb: "10",
            diskType: "pd-standard",
            sourceImage: "",
        }],
        "interface": "SCSI",
        mode: "READ_WRITE",
        type: "PERSISTENT",
    }],
    drainingTimeout: 180,
    fallbackToOndemand: true,
    instanceNamePrefix: "test-123a",
    instanceTypesCustoms: [{
        memoryGib: 7,
        vcpu: 2,
    }],
    instanceTypesOndemand: "n1-standard-1",
    instanceTypesPreemptibles: [
        "n1-standard-1",
        "n1-standard-2",
    ],
    labels: [{
        key: "test_key",
        value: "test_value",
    }],
    maxSize: 1,
    minSize: 0,
    networkInterfaces: [{
        network: "spot-network",
    }],
    preemptiblePercentage: 50,
    provisioningModel: "SPOT",
    scalingUpPolicies: [{
        actionType: "adjustment",
        adjustment: 1,
        cooldown: 300,
        dimensions: [{
            name: "storage_type",
            value: "pd-ssd",
        }],
        evaluationPeriods: 1,
        metricName: "instance/disk/read_ops_count",
        namespace: "compute",
        operator: "gte",
        period: 300,
        policyName: "scale_up_1",
        source: "stackdriver",
        statistic: "average",
        threshold: 10000,
        unit: "percent",
    }],
    serviceAccount: "example@myProject.iam.gservicecct.com",
    startupScript: "",
    subnets: [{
        region: "asia-east1",
        subnetNames: ["default"],
    }],
    tags: [
        "http",
        "https",
    ],
});
resources:
  example:
    type: spotinst:gcp:Elastigroup
    properties:
      availabilityZones:
        - asia-east1-c
        - us-central1-a
      backendServices:
        - locationType: regional
          namedPorts:
            - name: port-name
              ports:
                - 8000
                - 6000
          scheme: INTERNAL
          serviceName: spotinst-elb-backend-service
      description: spotinst gcp group
      desiredCapacity: 1
      disks:
        - autoDelete: true
          boot: true
          deviceName: device
          initializeParams:
            - diskSizeGb: 10
              diskType: pd-standard
              sourceImage:
          interface: SCSI
          mode: READ_WRITE
          type: PERSISTENT
      drainingTimeout: 180
      # on_demand_count      = 2
      fallbackToOndemand: true
      instanceNamePrefix: test-123a
      instanceTypesCustoms:
        - memoryGib: 7
          vcpu: 2
      instanceTypesOndemand: n1-standard-1
      instanceTypesPreemptibles:
        - n1-standard-1
        - n1-standard-2
      labels:
        - key: test_key
          value: test_value
      maxSize: 1
      minSize: 0
      networkInterfaces:
        - network: spot-network
      preemptiblePercentage: 50
      provisioningModel: SPOT
      scalingUpPolicies:
        - actionType: adjustment
          adjustment: 1
          cooldown: 300
          dimensions:
            - name: storage_type
              value: pd-ssd
          evaluationPeriods: 1
          metricName: instance/disk/read_ops_count
          namespace: compute
          operator: gte
          period: 300
          policyName: scale_up_1
          source: stackdriver
          statistic: average
          threshold: 10000
          unit: percent
      serviceAccount: example@myProject.iam.gservicecct.com
      startupScript:
      subnets:
        - region: asia-east1
          subnetNames:
            - default
      tags:
        - http
        - https

Create Elastigroup Resource

new Elastigroup(name: string, args: ElastigroupArgs, opts?: CustomResourceOptions);
@overload
def Elastigroup(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                auto_healing: Optional[bool] = None,
                availability_zones: Optional[Sequence[str]] = None,
                backend_services: Optional[Sequence[ElastigroupBackendServiceArgs]] = None,
                description: Optional[str] = None,
                desired_capacity: Optional[int] = None,
                disks: Optional[Sequence[ElastigroupDiskArgs]] = None,
                draining_timeout: Optional[int] = None,
                fallback_to_ondemand: Optional[bool] = None,
                gpu: Optional[Sequence[ElastigroupGpuArgs]] = None,
                health_check_grace_period: Optional[int] = None,
                health_check_type: Optional[str] = None,
                instance_name_prefix: Optional[str] = None,
                instance_types_customs: Optional[Sequence[ElastigroupInstanceTypesCustomArgs]] = None,
                instance_types_ondemand: Optional[str] = None,
                instance_types_preemptibles: Optional[Sequence[str]] = None,
                integration_docker_swarm: Optional[ElastigroupIntegrationDockerSwarmArgs] = None,
                integration_gke: Optional[ElastigroupIntegrationGkeArgs] = None,
                ip_forwarding: Optional[bool] = None,
                labels: Optional[Sequence[ElastigroupLabelArgs]] = None,
                max_size: Optional[int] = None,
                metadatas: Optional[Sequence[ElastigroupMetadataArgs]] = None,
                min_size: Optional[int] = None,
                name: Optional[str] = None,
                network_interfaces: Optional[Sequence[ElastigroupNetworkInterfaceArgs]] = None,
                ondemand_count: Optional[int] = None,
                preemptible_percentage: Optional[int] = None,
                provisioning_model: Optional[str] = None,
                scaling_down_policies: Optional[Sequence[ElastigroupScalingDownPolicyArgs]] = None,
                scaling_up_policies: Optional[Sequence[ElastigroupScalingUpPolicyArgs]] = None,
                scheduled_tasks: Optional[Sequence[ElastigroupScheduledTaskArgs]] = None,
                service_account: Optional[str] = None,
                shutdown_script: Optional[str] = None,
                startup_script: Optional[str] = None,
                subnets: Optional[Sequence[ElastigroupSubnetArgs]] = None,
                tags: Optional[Sequence[str]] = None,
                unhealthy_duration: Optional[int] = None)
@overload
def Elastigroup(resource_name: str,
                args: ElastigroupArgs,
                opts: Optional[ResourceOptions] = None)
func NewElastigroup(ctx *Context, name string, args ElastigroupArgs, opts ...ResourceOption) (*Elastigroup, error)
public Elastigroup(string name, ElastigroupArgs args, CustomResourceOptions? opts = null)
public Elastigroup(String name, ElastigroupArgs args)
public Elastigroup(String name, ElastigroupArgs args, CustomResourceOptions options)
type: spotinst:gcp:Elastigroup
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

name string
The unique name of the resource.
args ElastigroupArgs
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 ElastigroupArgs
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 ElastigroupArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name string
The unique name of the resource.
args ElastigroupArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name String
The unique name of the resource.
args ElastigroupArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Elastigroup Resource Properties

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

Inputs

The Elastigroup resource accepts the following input properties:

DesiredCapacity int

The desired number of instances the group should have at any time.

AutoHealing bool

Enable auto-replacement of unhealthy instances.

AvailabilityZones List<string>

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

BackendServices List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupBackendServiceArgs>
Description string

The region your GCP group will be created in.

Disks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupDiskArgs>
DrainingTimeout int

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

FallbackToOndemand bool

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

Gpu List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupGpuArgs>
HealthCheckGracePeriod int

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

HealthCheckType string

The kind of health check to perform when monitoring for unhealthiness.

InstanceNamePrefix string

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
InstanceTypesCustoms List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupInstanceTypesCustomArgs>

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

InstanceTypesOndemand string

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

InstanceTypesPreemptibles List<string>

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

IntegrationDockerSwarm Pulumi.SpotInst.Gcp.Inputs.ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

IntegrationGke Pulumi.SpotInst.Gcp.Inputs.ElastigroupIntegrationGkeArgs
IpForwarding bool
Labels List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupLabelArgs>

Array of objects with key-value pairs.

MaxSize int

The maximum number of instances the group should have at any time.

Metadatas List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupMetadataArgs>

Array of objects with key-value pairs.

MinSize int

The minimum number of instances the group should have at any time.

Name string

The group name.

NetworkInterfaces List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupNetworkInterfaceArgs>

Array of objects representing the network configuration for the elastigroup.

OndemandCount int
PreemptiblePercentage int

Percentage of Preemptible VMs to spin up from the "desired_capacity".

ProvisioningModel string

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

ScalingDownPolicies List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScalingDownPolicyArgs>

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

ScalingUpPolicies List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScalingUpPolicyArgs>

Contains scaling policies for scaling the Elastigroup up.

ScheduledTasks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScheduledTaskArgs>
ServiceAccount string

The email of the service account in which the group instances will be launched.

ShutdownScript string

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

StartupScript string

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

Subnets List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupSubnetArgs>

A list of regions and subnets.

Tags List<string>

Tags to mark created instances.

UnhealthyDuration int

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
DesiredCapacity int

The desired number of instances the group should have at any time.

AutoHealing bool

Enable auto-replacement of unhealthy instances.

AvailabilityZones []string

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

BackendServices []ElastigroupBackendServiceArgs
Description string

The region your GCP group will be created in.

Disks []ElastigroupDiskArgs
DrainingTimeout int

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

FallbackToOndemand bool

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

Gpu []ElastigroupGpuArgs
HealthCheckGracePeriod int

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

HealthCheckType string

The kind of health check to perform when monitoring for unhealthiness.

InstanceNamePrefix string

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
InstanceTypesCustoms []ElastigroupInstanceTypesCustomArgs

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

InstanceTypesOndemand string

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

InstanceTypesPreemptibles []string

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

IntegrationDockerSwarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

IntegrationGke ElastigroupIntegrationGkeArgs
IpForwarding bool
Labels []ElastigroupLabelArgs

Array of objects with key-value pairs.

MaxSize int

The maximum number of instances the group should have at any time.

Metadatas []ElastigroupMetadataArgs

Array of objects with key-value pairs.

MinSize int

The minimum number of instances the group should have at any time.

Name string

The group name.

NetworkInterfaces []ElastigroupNetworkInterfaceArgs

Array of objects representing the network configuration for the elastigroup.

OndemandCount int
PreemptiblePercentage int

Percentage of Preemptible VMs to spin up from the "desired_capacity".

ProvisioningModel string

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

ScalingDownPolicies []ElastigroupScalingDownPolicyArgs

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

ScalingUpPolicies []ElastigroupScalingUpPolicyArgs

Contains scaling policies for scaling the Elastigroup up.

ScheduledTasks []ElastigroupScheduledTaskArgs
ServiceAccount string

The email of the service account in which the group instances will be launched.

ShutdownScript string

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

StartupScript string

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

Subnets []ElastigroupSubnetArgs

A list of regions and subnets.

Tags []string

Tags to mark created instances.

UnhealthyDuration int

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
desiredCapacity Integer

The desired number of instances the group should have at any time.

autoHealing Boolean

Enable auto-replacement of unhealthy instances.

availabilityZones List<String>

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backendServices List<ElastigroupBackendServiceArgs>
description String

The region your GCP group will be created in.

disks List<ElastigroupDiskArgs>
drainingTimeout Integer

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallbackToOndemand Boolean

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu List<ElastigroupGpuArgs>
healthCheckGracePeriod Integer

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

healthCheckType String

The kind of health check to perform when monitoring for unhealthiness.

instanceNamePrefix String

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instanceTypesCustoms List<ElastigroupInstanceTypesCustomArgs>

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instanceTypesOndemand String

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instanceTypesPreemptibles List<String>

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integrationDockerSwarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

integrationGke ElastigroupIntegrationGkeArgs
ipForwarding Boolean
labels List<ElastigroupLabelArgs>

Array of objects with key-value pairs.

maxSize Integer

The maximum number of instances the group should have at any time.

metadatas List<ElastigroupMetadataArgs>

Array of objects with key-value pairs.

minSize Integer

The minimum number of instances the group should have at any time.

name String

The group name.

networkInterfaces List<ElastigroupNetworkInterfaceArgs>

Array of objects representing the network configuration for the elastigroup.

ondemandCount Integer
preemptiblePercentage Integer

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioningModel String

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scalingDownPolicies List<ElastigroupScalingDownPolicyArgs>

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scalingUpPolicies List<ElastigroupScalingUpPolicyArgs>

Contains scaling policies for scaling the Elastigroup up.

scheduledTasks List<ElastigroupScheduledTaskArgs>
serviceAccount String

The email of the service account in which the group instances will be launched.

shutdownScript String

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startupScript String

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets List<ElastigroupSubnetArgs>

A list of regions and subnets.

tags List<String>

Tags to mark created instances.

unhealthyDuration Integer

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
desiredCapacity number

The desired number of instances the group should have at any time.

autoHealing boolean

Enable auto-replacement of unhealthy instances.

availabilityZones string[]

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backendServices ElastigroupBackendServiceArgs[]
description string

The region your GCP group will be created in.

disks ElastigroupDiskArgs[]
drainingTimeout number

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallbackToOndemand boolean

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu ElastigroupGpuArgs[]
healthCheckGracePeriod number

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

healthCheckType string

The kind of health check to perform when monitoring for unhealthiness.

instanceNamePrefix string

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instanceTypesCustoms ElastigroupInstanceTypesCustomArgs[]

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instanceTypesOndemand string

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instanceTypesPreemptibles string[]

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integrationDockerSwarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

integrationGke ElastigroupIntegrationGkeArgs
ipForwarding boolean
labels ElastigroupLabelArgs[]

Array of objects with key-value pairs.

maxSize number

The maximum number of instances the group should have at any time.

metadatas ElastigroupMetadataArgs[]

Array of objects with key-value pairs.

minSize number

The minimum number of instances the group should have at any time.

name string

The group name.

networkInterfaces ElastigroupNetworkInterfaceArgs[]

Array of objects representing the network configuration for the elastigroup.

ondemandCount number
preemptiblePercentage number

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioningModel string

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scalingDownPolicies ElastigroupScalingDownPolicyArgs[]

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scalingUpPolicies ElastigroupScalingUpPolicyArgs[]

Contains scaling policies for scaling the Elastigroup up.

scheduledTasks ElastigroupScheduledTaskArgs[]
serviceAccount string

The email of the service account in which the group instances will be launched.

shutdownScript string

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startupScript string

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets ElastigroupSubnetArgs[]

A list of regions and subnets.

tags string[]

Tags to mark created instances.

unhealthyDuration number

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
desired_capacity int

The desired number of instances the group should have at any time.

auto_healing bool

Enable auto-replacement of unhealthy instances.

availability_zones Sequence[str]

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backend_services Sequence[ElastigroupBackendServiceArgs]
description str

The region your GCP group will be created in.

disks Sequence[ElastigroupDiskArgs]
draining_timeout int

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallback_to_ondemand bool

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu Sequence[ElastigroupGpuArgs]
health_check_grace_period int

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

health_check_type str

The kind of health check to perform when monitoring for unhealthiness.

instance_name_prefix str

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instance_types_customs Sequence[ElastigroupInstanceTypesCustomArgs]

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instance_types_ondemand str

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instance_types_preemptibles Sequence[str]

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integration_docker_swarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

integration_gke ElastigroupIntegrationGkeArgs
ip_forwarding bool
labels Sequence[ElastigroupLabelArgs]

Array of objects with key-value pairs.

max_size int

The maximum number of instances the group should have at any time.

metadatas Sequence[ElastigroupMetadataArgs]

Array of objects with key-value pairs.

min_size int

The minimum number of instances the group should have at any time.

name str

The group name.

network_interfaces Sequence[ElastigroupNetworkInterfaceArgs]

Array of objects representing the network configuration for the elastigroup.

ondemand_count int
preemptible_percentage int

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioning_model str

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scaling_down_policies Sequence[ElastigroupScalingDownPolicyArgs]

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scaling_up_policies Sequence[ElastigroupScalingUpPolicyArgs]

Contains scaling policies for scaling the Elastigroup up.

scheduled_tasks Sequence[ElastigroupScheduledTaskArgs]
service_account str

The email of the service account in which the group instances will be launched.

shutdown_script str

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startup_script str

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets Sequence[ElastigroupSubnetArgs]

A list of regions and subnets.

tags Sequence[str]

Tags to mark created instances.

unhealthy_duration int

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
desiredCapacity Number

The desired number of instances the group should have at any time.

autoHealing Boolean

Enable auto-replacement of unhealthy instances.

availabilityZones List<String>

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backendServices List<Property Map>
description String

The region your GCP group will be created in.

disks List<Property Map>
drainingTimeout Number

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallbackToOndemand Boolean

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu List<Property Map>
healthCheckGracePeriod Number

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

healthCheckType String

The kind of health check to perform when monitoring for unhealthiness.

instanceNamePrefix String

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instanceTypesCustoms List<Property Map>

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instanceTypesOndemand String

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instanceTypesPreemptibles List<String>

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integrationDockerSwarm Property Map

Describes the Docker Swarm integration.

integrationGke Property Map
ipForwarding Boolean
labels List<Property Map>

Array of objects with key-value pairs.

maxSize Number

The maximum number of instances the group should have at any time.

metadatas List<Property Map>

Array of objects with key-value pairs.

minSize Number

The minimum number of instances the group should have at any time.

name String

The group name.

networkInterfaces List<Property Map>

Array of objects representing the network configuration for the elastigroup.

ondemandCount Number
preemptiblePercentage Number

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioningModel String

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scalingDownPolicies List<Property Map>

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scalingUpPolicies List<Property Map>

Contains scaling policies for scaling the Elastigroup up.

scheduledTasks List<Property Map>
serviceAccount String

The email of the service account in which the group instances will be launched.

shutdownScript String

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startupScript String

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets List<Property Map>

A list of regions and subnets.

tags List<String>

Tags to mark created instances.

unhealthyDuration Number

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}

Outputs

All input properties are implicitly available as output properties. Additionally, the Elastigroup 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 Elastigroup Resource

Get an existing Elastigroup 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?: ElastigroupState, opts?: CustomResourceOptions): Elastigroup
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        auto_healing: Optional[bool] = None,
        availability_zones: Optional[Sequence[str]] = None,
        backend_services: Optional[Sequence[ElastigroupBackendServiceArgs]] = None,
        description: Optional[str] = None,
        desired_capacity: Optional[int] = None,
        disks: Optional[Sequence[ElastigroupDiskArgs]] = None,
        draining_timeout: Optional[int] = None,
        fallback_to_ondemand: Optional[bool] = None,
        gpu: Optional[Sequence[ElastigroupGpuArgs]] = None,
        health_check_grace_period: Optional[int] = None,
        health_check_type: Optional[str] = None,
        instance_name_prefix: Optional[str] = None,
        instance_types_customs: Optional[Sequence[ElastigroupInstanceTypesCustomArgs]] = None,
        instance_types_ondemand: Optional[str] = None,
        instance_types_preemptibles: Optional[Sequence[str]] = None,
        integration_docker_swarm: Optional[ElastigroupIntegrationDockerSwarmArgs] = None,
        integration_gke: Optional[ElastigroupIntegrationGkeArgs] = None,
        ip_forwarding: Optional[bool] = None,
        labels: Optional[Sequence[ElastigroupLabelArgs]] = None,
        max_size: Optional[int] = None,
        metadatas: Optional[Sequence[ElastigroupMetadataArgs]] = None,
        min_size: Optional[int] = None,
        name: Optional[str] = None,
        network_interfaces: Optional[Sequence[ElastigroupNetworkInterfaceArgs]] = None,
        ondemand_count: Optional[int] = None,
        preemptible_percentage: Optional[int] = None,
        provisioning_model: Optional[str] = None,
        scaling_down_policies: Optional[Sequence[ElastigroupScalingDownPolicyArgs]] = None,
        scaling_up_policies: Optional[Sequence[ElastigroupScalingUpPolicyArgs]] = None,
        scheduled_tasks: Optional[Sequence[ElastigroupScheduledTaskArgs]] = None,
        service_account: Optional[str] = None,
        shutdown_script: Optional[str] = None,
        startup_script: Optional[str] = None,
        subnets: Optional[Sequence[ElastigroupSubnetArgs]] = None,
        tags: Optional[Sequence[str]] = None,
        unhealthy_duration: Optional[int] = None) -> Elastigroup
func GetElastigroup(ctx *Context, name string, id IDInput, state *ElastigroupState, opts ...ResourceOption) (*Elastigroup, error)
public static Elastigroup Get(string name, Input<string> id, ElastigroupState? state, CustomResourceOptions? opts = null)
public static Elastigroup get(String name, Output<String> id, ElastigroupState state, CustomResourceOptions options)
Resource lookup is not supported in YAML
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:
AutoHealing bool

Enable auto-replacement of unhealthy instances.

AvailabilityZones List<string>

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

BackendServices List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupBackendServiceArgs>
Description string

The region your GCP group will be created in.

DesiredCapacity int

The desired number of instances the group should have at any time.

Disks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupDiskArgs>
DrainingTimeout int

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

FallbackToOndemand bool

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

Gpu List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupGpuArgs>
HealthCheckGracePeriod int

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

HealthCheckType string

The kind of health check to perform when monitoring for unhealthiness.

InstanceNamePrefix string

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
InstanceTypesCustoms List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupInstanceTypesCustomArgs>

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

InstanceTypesOndemand string

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

InstanceTypesPreemptibles List<string>

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

IntegrationDockerSwarm Pulumi.SpotInst.Gcp.Inputs.ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

IntegrationGke Pulumi.SpotInst.Gcp.Inputs.ElastigroupIntegrationGkeArgs
IpForwarding bool
Labels List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupLabelArgs>

Array of objects with key-value pairs.

MaxSize int

The maximum number of instances the group should have at any time.

Metadatas List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupMetadataArgs>

Array of objects with key-value pairs.

MinSize int

The minimum number of instances the group should have at any time.

Name string

The group name.

NetworkInterfaces List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupNetworkInterfaceArgs>

Array of objects representing the network configuration for the elastigroup.

OndemandCount int
PreemptiblePercentage int

Percentage of Preemptible VMs to spin up from the "desired_capacity".

ProvisioningModel string

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

ScalingDownPolicies List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScalingDownPolicyArgs>

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

ScalingUpPolicies List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScalingUpPolicyArgs>

Contains scaling policies for scaling the Elastigroup up.

ScheduledTasks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScheduledTaskArgs>
ServiceAccount string

The email of the service account in which the group instances will be launched.

ShutdownScript string

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

StartupScript string

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

Subnets List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupSubnetArgs>

A list of regions and subnets.

Tags List<string>

Tags to mark created instances.

UnhealthyDuration int

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
AutoHealing bool

Enable auto-replacement of unhealthy instances.

AvailabilityZones []string

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

BackendServices []ElastigroupBackendServiceArgs
Description string

The region your GCP group will be created in.

DesiredCapacity int

The desired number of instances the group should have at any time.

Disks []ElastigroupDiskArgs
DrainingTimeout int

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

FallbackToOndemand bool

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

Gpu []ElastigroupGpuArgs
HealthCheckGracePeriod int

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

HealthCheckType string

The kind of health check to perform when monitoring for unhealthiness.

InstanceNamePrefix string

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
InstanceTypesCustoms []ElastigroupInstanceTypesCustomArgs

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

InstanceTypesOndemand string

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

InstanceTypesPreemptibles []string

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

IntegrationDockerSwarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

IntegrationGke ElastigroupIntegrationGkeArgs
IpForwarding bool
Labels []ElastigroupLabelArgs

Array of objects with key-value pairs.

MaxSize int

The maximum number of instances the group should have at any time.

Metadatas []ElastigroupMetadataArgs

Array of objects with key-value pairs.

MinSize int

The minimum number of instances the group should have at any time.

Name string

The group name.

NetworkInterfaces []ElastigroupNetworkInterfaceArgs

Array of objects representing the network configuration for the elastigroup.

OndemandCount int
PreemptiblePercentage int

Percentage of Preemptible VMs to spin up from the "desired_capacity".

ProvisioningModel string

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

ScalingDownPolicies []ElastigroupScalingDownPolicyArgs

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

ScalingUpPolicies []ElastigroupScalingUpPolicyArgs

Contains scaling policies for scaling the Elastigroup up.

ScheduledTasks []ElastigroupScheduledTaskArgs
ServiceAccount string

The email of the service account in which the group instances will be launched.

ShutdownScript string

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

StartupScript string

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

Subnets []ElastigroupSubnetArgs

A list of regions and subnets.

Tags []string

Tags to mark created instances.

UnhealthyDuration int

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
autoHealing Boolean

Enable auto-replacement of unhealthy instances.

availabilityZones List<String>

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backendServices List<ElastigroupBackendServiceArgs>
description String

The region your GCP group will be created in.

desiredCapacity Integer

The desired number of instances the group should have at any time.

disks List<ElastigroupDiskArgs>
drainingTimeout Integer

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallbackToOndemand Boolean

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu List<ElastigroupGpuArgs>
healthCheckGracePeriod Integer

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

healthCheckType String

The kind of health check to perform when monitoring for unhealthiness.

instanceNamePrefix String

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instanceTypesCustoms List<ElastigroupInstanceTypesCustomArgs>

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instanceTypesOndemand String

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instanceTypesPreemptibles List<String>

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integrationDockerSwarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

integrationGke ElastigroupIntegrationGkeArgs
ipForwarding Boolean
labels List<ElastigroupLabelArgs>

Array of objects with key-value pairs.

maxSize Integer

The maximum number of instances the group should have at any time.

metadatas List<ElastigroupMetadataArgs>

Array of objects with key-value pairs.

minSize Integer

The minimum number of instances the group should have at any time.

name String

The group name.

networkInterfaces List<ElastigroupNetworkInterfaceArgs>

Array of objects representing the network configuration for the elastigroup.

ondemandCount Integer
preemptiblePercentage Integer

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioningModel String

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scalingDownPolicies List<ElastigroupScalingDownPolicyArgs>

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scalingUpPolicies List<ElastigroupScalingUpPolicyArgs>

Contains scaling policies for scaling the Elastigroup up.

scheduledTasks List<ElastigroupScheduledTaskArgs>
serviceAccount String

The email of the service account in which the group instances will be launched.

shutdownScript String

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startupScript String

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets List<ElastigroupSubnetArgs>

A list of regions and subnets.

tags List<String>

Tags to mark created instances.

unhealthyDuration Integer

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
autoHealing boolean

Enable auto-replacement of unhealthy instances.

availabilityZones string[]

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backendServices ElastigroupBackendServiceArgs[]
description string

The region your GCP group will be created in.

desiredCapacity number

The desired number of instances the group should have at any time.

disks ElastigroupDiskArgs[]
drainingTimeout number

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallbackToOndemand boolean

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu ElastigroupGpuArgs[]
healthCheckGracePeriod number

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

healthCheckType string

The kind of health check to perform when monitoring for unhealthiness.

instanceNamePrefix string

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instanceTypesCustoms ElastigroupInstanceTypesCustomArgs[]

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instanceTypesOndemand string

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instanceTypesPreemptibles string[]

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integrationDockerSwarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

integrationGke ElastigroupIntegrationGkeArgs
ipForwarding boolean
labels ElastigroupLabelArgs[]

Array of objects with key-value pairs.

maxSize number

The maximum number of instances the group should have at any time.

metadatas ElastigroupMetadataArgs[]

Array of objects with key-value pairs.

minSize number

The minimum number of instances the group should have at any time.

name string

The group name.

networkInterfaces ElastigroupNetworkInterfaceArgs[]

Array of objects representing the network configuration for the elastigroup.

ondemandCount number
preemptiblePercentage number

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioningModel string

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scalingDownPolicies ElastigroupScalingDownPolicyArgs[]

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scalingUpPolicies ElastigroupScalingUpPolicyArgs[]

Contains scaling policies for scaling the Elastigroup up.

scheduledTasks ElastigroupScheduledTaskArgs[]
serviceAccount string

The email of the service account in which the group instances will be launched.

shutdownScript string

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startupScript string

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets ElastigroupSubnetArgs[]

A list of regions and subnets.

tags string[]

Tags to mark created instances.

unhealthyDuration number

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
auto_healing bool

Enable auto-replacement of unhealthy instances.

availability_zones Sequence[str]

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backend_services Sequence[ElastigroupBackendServiceArgs]
description str

The region your GCP group will be created in.

desired_capacity int

The desired number of instances the group should have at any time.

disks Sequence[ElastigroupDiskArgs]
draining_timeout int

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallback_to_ondemand bool

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu Sequence[ElastigroupGpuArgs]
health_check_grace_period int

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

health_check_type str

The kind of health check to perform when monitoring for unhealthiness.

instance_name_prefix str

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instance_types_customs Sequence[ElastigroupInstanceTypesCustomArgs]

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instance_types_ondemand str

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instance_types_preemptibles Sequence[str]

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integration_docker_swarm ElastigroupIntegrationDockerSwarmArgs

Describes the Docker Swarm integration.

integration_gke ElastigroupIntegrationGkeArgs
ip_forwarding bool
labels Sequence[ElastigroupLabelArgs]

Array of objects with key-value pairs.

max_size int

The maximum number of instances the group should have at any time.

metadatas Sequence[ElastigroupMetadataArgs]

Array of objects with key-value pairs.

min_size int

The minimum number of instances the group should have at any time.

name str

The group name.

network_interfaces Sequence[ElastigroupNetworkInterfaceArgs]

Array of objects representing the network configuration for the elastigroup.

ondemand_count int
preemptible_percentage int

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioning_model str

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scaling_down_policies Sequence[ElastigroupScalingDownPolicyArgs]

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scaling_up_policies Sequence[ElastigroupScalingUpPolicyArgs]

Contains scaling policies for scaling the Elastigroup up.

scheduled_tasks Sequence[ElastigroupScheduledTaskArgs]
service_account str

The email of the service account in which the group instances will be launched.

shutdown_script str

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startup_script str

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets Sequence[ElastigroupSubnetArgs]

A list of regions and subnets.

tags Sequence[str]

Tags to mark created instances.

unhealthy_duration int

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
autoHealing Boolean

Enable auto-replacement of unhealthy instances.

availabilityZones List<String>

List of availability zones for the group.

Deprecated:

This field will soon be handled by Region in Subnets

backendServices List<Property Map>
description String

The region your GCP group will be created in.

desiredCapacity Number

The desired number of instances the group should have at any time.

disks List<Property Map>
drainingTimeout Number

Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.

fallbackToOndemand Boolean

Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.

gpu List<Property Map>
healthCheckGracePeriod Number

Period of time (seconds) to wait for VM to reach healthiness before monitoring for unhealthiness.

healthCheckType String

The kind of health check to perform when monitoring for unhealthiness.

instanceNamePrefix String

Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:

  • A maximal length of 25 characters.
  • The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
instanceTypesCustoms List<Property Map>

Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.

instanceTypesOndemand String

The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.

instanceTypesPreemptibles List<String>

The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.

integrationDockerSwarm Property Map

Describes the Docker Swarm integration.

integrationGke Property Map
ipForwarding Boolean
labels List<Property Map>

Array of objects with key-value pairs.

maxSize Number

The maximum number of instances the group should have at any time.

metadatas List<Property Map>

Array of objects with key-value pairs.

minSize Number

The minimum number of instances the group should have at any time.

name String

The group name.

networkInterfaces List<Property Map>

Array of objects representing the network configuration for the elastigroup.

ondemandCount Number
preemptiblePercentage Number

Percentage of Preemptible VMs to spin up from the "desired_capacity".

provisioningModel String

Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".

scalingDownPolicies List<Property Map>

Contains scaling policies for scaling the Elastigroup down.

Each scaling_*_policy supports the following:

scalingUpPolicies List<Property Map>

Contains scaling policies for scaling the Elastigroup up.

scheduledTasks List<Property Map>
serviceAccount String

The email of the service account in which the group instances will be launched.

shutdownScript String

The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: Shutdown Script

startupScript String

Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.

subnets List<Property Map>

A list of regions and subnets.

tags List<String>

Tags to mark created instances.

unhealthyDuration Number

Period of time (seconds) to remain in an unhealthy status before a replacement is triggered.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}

Supporting Types

ElastigroupBackendService

ServiceName string

The name of the backend service.

LocationType string

Sets which location the backend services will be active. Valid values: regional, global.

NamedPorts List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupBackendServiceNamedPort>

Describes a named port and a list of ports.

Scheme string

Use when location_type is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: INTERNAL, EXTERNAL.

ServiceName string

The name of the backend service.

LocationType string

Sets which location the backend services will be active. Valid values: regional, global.

NamedPorts []ElastigroupBackendServiceNamedPort

Describes a named port and a list of ports.

Scheme string

Use when location_type is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: INTERNAL, EXTERNAL.

serviceName String

The name of the backend service.

locationType String

Sets which location the backend services will be active. Valid values: regional, global.

namedPorts List<ElastigroupBackendServiceNamedPort>

Describes a named port and a list of ports.

scheme String

Use when location_type is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: INTERNAL, EXTERNAL.

serviceName string

The name of the backend service.

locationType string

Sets which location the backend services will be active. Valid values: regional, global.

namedPorts ElastigroupBackendServiceNamedPort[]

Describes a named port and a list of ports.

scheme string

Use when location_type is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: INTERNAL, EXTERNAL.

service_name str

The name of the backend service.

location_type str

Sets which location the backend services will be active. Valid values: regional, global.

named_ports Sequence[ElastigroupBackendServiceNamedPort]

Describes a named port and a list of ports.

scheme str

Use when location_type is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: INTERNAL, EXTERNAL.

serviceName String

The name of the backend service.

locationType String

Sets which location the backend services will be active. Valid values: regional, global.

namedPorts List<Property Map>

Describes a named port and a list of ports.

scheme String

Use when location_type is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: INTERNAL, EXTERNAL.

ElastigroupBackendServiceNamedPort

Name string

The group name.

Ports List<string>

A list of ports.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
Name string

The group name.

Ports []string

A list of ports.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name String

The group name.

ports List<String>

A list of ports.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name string

The group name.

ports string[]

A list of ports.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name str

The group name.

ports Sequence[str]

A list of ports.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name String

The group name.

ports List<String>

A list of ports.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}

ElastigroupDisk

AutoDelete bool

Specifies whether the disk will be auto-deleted when the instance is deleted.

Boot bool

Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.

DeviceName string

Specifies a unique device name of your choice.

InitializeParams List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupDiskInitializeParam>

Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.

Interface string

Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.

Mode string

The mode in which to attach this disk, either READ_WRITE or READ_ONLY.

Source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

Type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
AutoDelete bool

Specifies whether the disk will be auto-deleted when the instance is deleted.

Boot bool

Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.

DeviceName string

Specifies a unique device name of your choice.

InitializeParams []ElastigroupDiskInitializeParam

Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.

Interface string

Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.

Mode string

The mode in which to attach this disk, either READ_WRITE or READ_ONLY.

Source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

Type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
autoDelete Boolean

Specifies whether the disk will be auto-deleted when the instance is deleted.

boot Boolean

Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.

deviceName String

Specifies a unique device name of your choice.

initializeParams List<ElastigroupDiskInitializeParam>

Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.

interface_ String

Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.

mode String

The mode in which to attach this disk, either READ_WRITE or READ_ONLY.

source String

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

type String

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
autoDelete boolean

Specifies whether the disk will be auto-deleted when the instance is deleted.

boot boolean

Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.

deviceName string

Specifies a unique device name of your choice.

initializeParams ElastigroupDiskInitializeParam[]

Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.

interface string

Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.

mode string

The mode in which to attach this disk, either READ_WRITE or READ_ONLY.

source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
auto_delete bool

Specifies whether the disk will be auto-deleted when the instance is deleted.

boot bool

Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.

device_name str

Specifies a unique device name of your choice.

initialize_params Sequence[ElastigroupDiskInitializeParam]

Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.

interface str

Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.

mode str

The mode in which to attach this disk, either READ_WRITE or READ_ONLY.

source str

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

type str

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
autoDelete Boolean

Specifies whether the disk will be auto-deleted when the instance is deleted.

boot Boolean

Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.

deviceName String

Specifies a unique device name of your choice.

initializeParams List<Property Map>

Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.

interface String

Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.

mode String

The mode in which to attach this disk, either READ_WRITE or READ_ONLY.

source String

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

type String

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}

ElastigroupDiskInitializeParam

SourceImage string

A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
DiskSizeGb string

Specifies disk size in gigabytes. Must be in increments of 2.

DiskType string

Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.

SourceImage string

A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
DiskSizeGb string

Specifies disk size in gigabytes. Must be in increments of 2.

DiskType string

Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.

sourceImage String

A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
diskSizeGb String

Specifies disk size in gigabytes. Must be in increments of 2.

diskType String

Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.

sourceImage string

A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
diskSizeGb string

Specifies disk size in gigabytes. Must be in increments of 2.

diskType string

Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.

source_image str

A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
disk_size_gb str

Specifies disk size in gigabytes. Must be in increments of 2.

disk_type str

Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.

sourceImage String

A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
diskSizeGb String

Specifies disk size in gigabytes. Must be in increments of 2.

diskType String

Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.

ElastigroupGpu

Count int

The number of GPUs. Must be 0, 2, 4, 6, 8.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
Type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

Count int

The number of GPUs. Must be 0, 2, 4, 6, 8.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
Type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

count Integer

The number of GPUs. Must be 0, 2, 4, 6, 8.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
type String

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

count number

The number of GPUs. Must be 0, 2, 4, 6, 8.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

count int

The number of GPUs. Must be 0, 2, 4, 6, 8.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
type str

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

count Number

The number of GPUs. Must be 0, 2, 4, 6, 8.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
type String

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

ElastigroupInstanceTypesCustom

MemoryGib int

The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]

Vcpu int
MemoryGib int

The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]

Vcpu int
memoryGib Integer

The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]

vcpu Integer
memoryGib number

The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]

vcpu number
memory_gib int

The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]

vcpu int
memoryGib Number

The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]

vcpu Number

ElastigroupIntegrationDockerSwarm

MasterHost string

IP or FQDN of one of your swarm managers.

MasterPort int

Network port used by your swarm.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
MasterHost string

IP or FQDN of one of your swarm managers.

MasterPort int

Network port used by your swarm.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
masterHost String

IP or FQDN of one of your swarm managers.

masterPort Integer

Network port used by your swarm.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
masterHost string

IP or FQDN of one of your swarm managers.

masterPort number

Network port used by your swarm.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
master_host str

IP or FQDN of one of your swarm managers.

master_port int

Network port used by your swarm.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
masterHost String

IP or FQDN of one of your swarm managers.

masterPort Number

Network port used by your swarm.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}

ElastigroupIntegrationGke

ElastigroupIntegrationGkeAutoscaleDown

EvaluationPeriods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

EvaluationPeriods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

evaluationPeriods Integer

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

evaluationPeriods number

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

evaluation_periods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

evaluationPeriods Number

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

ElastigroupIntegrationGkeAutoscaleHeadroom

cpuPerUnit Integer
memoryPerUnit Integer
numOfUnits Integer

ElastigroupIntegrationGkeAutoscaleLabel

Key string

Labels key.

Value string

Labels value.

Key string

Labels key.

Value string

Labels value.

key String

Labels key.

value String

Labels value.

key string

Labels key.

value string

Labels value.

key str

Labels key.

value str

Labels value.

key String

Labels key.

value String

Labels value.

ElastigroupLabel

Key string

Labels key.

Value string

Labels value.

Key string

Labels key.

Value string

Labels value.

key String

Labels key.

value String

Labels value.

key string

Labels key.

value string

Labels value.

key str

Labels key.

value str

Labels value.

key String

Labels key.

value String

Labels value.

ElastigroupMetadata

Key string

Labels key.

Value string

Labels value.

Key string

Labels key.

Value string

Labels value.

key String

Labels key.

value String

Labels value.

key string

Labels key.

value string

Labels value.

key str

Labels key.

value str

Labels value.

key String

Labels key.

value String

Labels value.

ElastigroupNetworkInterface

network String

Network resource for this group.

accessConfigs List<Property Map>

Array of configurations.

aliasIpRanges List<Property Map>

ElastigroupNetworkInterfaceAccessConfig

Name string

The group name.

Type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
Name string

The group name.

Type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name String

The group name.

type String

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name string

The group name.

type string

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name str

The group name.

type str

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
name String

The group name.

type String

The type of GPU instance. Valid values: nvidia-tesla-v100, nvidia-tesla-p100, nvidia-tesla-k80.

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}

ElastigroupNetworkInterfaceAliasIpRange

ElastigroupScalingDownPolicy

MetricName string

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

Namespace string
PolicyName string

Name of scaling policy.

Threshold double

The value at which the scaling action is triggered.

Unit string
ActionType string

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

Adjustment int

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

Cooldown int

Time (seconds) to wait after a scaling action before resuming monitoring.

Dimensions List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScalingDownPolicyDimension>

A list of dimensions describing qualities of the metric.

EvaluationPeriods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

Operator string

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

Period int

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

Source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

Statistic string

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

MetricName string

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

Namespace string
PolicyName string

Name of scaling policy.

Threshold float64

The value at which the scaling action is triggered.

Unit string
ActionType string

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

Adjustment int

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

Cooldown int

Time (seconds) to wait after a scaling action before resuming monitoring.

Dimensions []ElastigroupScalingDownPolicyDimension

A list of dimensions describing qualities of the metric.

EvaluationPeriods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

Operator string

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

Period int

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

Source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

Statistic string

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metricName String

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace String
policyName String

Name of scaling policy.

threshold Double

The value at which the scaling action is triggered.

unit String
actionType String

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment Integer

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown Integer

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions List<ElastigroupScalingDownPolicyDimension>

A list of dimensions describing qualities of the metric.

evaluationPeriods Integer

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator String

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period Integer

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source String

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic String

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metricName string

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace string
policyName string

Name of scaling policy.

threshold number

The value at which the scaling action is triggered.

unit string
actionType string

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment number

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown number

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions ElastigroupScalingDownPolicyDimension[]

A list of dimensions describing qualities of the metric.

evaluationPeriods number

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator string

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period number

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic string

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metric_name str

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace str
policy_name str

Name of scaling policy.

threshold float

The value at which the scaling action is triggered.

unit str
action_type str

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment int

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown int

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions Sequence[ElastigroupScalingDownPolicyDimension]

A list of dimensions describing qualities of the metric.

evaluation_periods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator str

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period int

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source str

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic str

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metricName String

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace String
policyName String

Name of scaling policy.

threshold Number

The value at which the scaling action is triggered.

unit String
actionType String

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment Number

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown Number

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions List<Property Map>

A list of dimensions describing qualities of the metric.

evaluationPeriods Number

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator String

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period Number

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source String

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic String

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

ElastigroupScalingDownPolicyDimension

Name string

The group name.

Value string

Labels value.

Name string

The group name.

Value string

Labels value.

name String

The group name.

value String

Labels value.

name string

The group name.

value string

Labels value.

name str

The group name.

value str

Labels value.

name String

The group name.

value String

Labels value.

ElastigroupScalingUpPolicy

MetricName string

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

Namespace string
PolicyName string

Name of scaling policy.

Threshold double

The value at which the scaling action is triggered.

Unit string
ActionType string

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

Adjustment int

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

Cooldown int

Time (seconds) to wait after a scaling action before resuming monitoring.

Dimensions List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScalingUpPolicyDimension>

A list of dimensions describing qualities of the metric.

EvaluationPeriods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

Operator string

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

Period int

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

Source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

Statistic string

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

MetricName string

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

Namespace string
PolicyName string

Name of scaling policy.

Threshold float64

The value at which the scaling action is triggered.

Unit string
ActionType string

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

Adjustment int

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

Cooldown int

Time (seconds) to wait after a scaling action before resuming monitoring.

Dimensions []ElastigroupScalingUpPolicyDimension

A list of dimensions describing qualities of the metric.

EvaluationPeriods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

Operator string

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

Period int

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

Source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

Statistic string

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metricName String

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace String
policyName String

Name of scaling policy.

threshold Double

The value at which the scaling action is triggered.

unit String
actionType String

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment Integer

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown Integer

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions List<ElastigroupScalingUpPolicyDimension>

A list of dimensions describing qualities of the metric.

evaluationPeriods Integer

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator String

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period Integer

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source String

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic String

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metricName string

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace string
policyName string

Name of scaling policy.

threshold number

The value at which the scaling action is triggered.

unit string
actionType string

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment number

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown number

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions ElastigroupScalingUpPolicyDimension[]

A list of dimensions describing qualities of the metric.

evaluationPeriods number

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator string

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period number

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source string

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic string

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metric_name str

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace str
policy_name str

Name of scaling policy.

threshold float

The value at which the scaling action is triggered.

unit str
action_type str

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment int

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown int

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions Sequence[ElastigroupScalingUpPolicyDimension]

A list of dimensions describing qualities of the metric.

evaluation_periods int

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator str

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period int

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source str

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic str

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

metricName String

Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".

namespace String
policyName String

Name of scaling policy.

threshold Number

The value at which the scaling action is triggered.

unit String
actionType String

Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"

adjustment Number

Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.

cooldown Number

Time (seconds) to wait after a scaling action before resuming monitoring.

dimensions List<Property Map>

A list of dimensions describing qualities of the metric.

evaluationPeriods Number

Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.

operator String

The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).

period Number

Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.

source String

Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.

statistic String

Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".

ElastigroupScalingUpPolicyDimension

Name string

The group name.

Value string

Labels value.

Name string

The group name.

Value string

Labels value.

name String

The group name.

value String

Labels value.

name string

The group name.

value string

Labels value.

name str

The group name.

value str

Labels value.

name String

The group name.

value String

Labels value.

ElastigroupScheduledTask

TaskType string

The task type to run. Valid values: "setCapacity".

CronExpression string

A valid cron expression. The cron is running in UTC time zone and is in Unix cron format.

IsEnabled bool

Setting the task to being enabled or disabled.

MaxCapacity string

The maximum number of instances the group should have.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
MinCapacity string

The minimum number of instances the group should have.

TargetCapacity string

The desired number of instances the group should have.

TaskType string

The task type to run. Valid values: "setCapacity".

CronExpression string

A valid cron expression. The cron is running in UTC time zone and is in Unix cron format.

IsEnabled bool

Setting the task to being enabled or disabled.

MaxCapacity string

The maximum number of instances the group should have.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
MinCapacity string

The minimum number of instances the group should have.

TargetCapacity string

The desired number of instances the group should have.

taskType String

The task type to run. Valid values: "setCapacity".

cronExpression String

A valid cron expression. The cron is running in UTC time zone and is in Unix cron format.

isEnabled Boolean

Setting the task to being enabled or disabled.

maxCapacity String

The maximum number of instances the group should have.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
minCapacity String

The minimum number of instances the group should have.

targetCapacity String

The desired number of instances the group should have.

taskType string

The task type to run. Valid values: "setCapacity".

cronExpression string

A valid cron expression. The cron is running in UTC time zone and is in Unix cron format.

isEnabled boolean

Setting the task to being enabled or disabled.

maxCapacity string

The maximum number of instances the group should have.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
minCapacity string

The minimum number of instances the group should have.

targetCapacity string

The desired number of instances the group should have.

task_type str

The task type to run. Valid values: "setCapacity".

cron_expression str

A valid cron expression. The cron is running in UTC time zone and is in Unix cron format.

is_enabled bool

Setting the task to being enabled or disabled.

max_capacity str

The maximum number of instances the group should have.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
min_capacity str

The minimum number of instances the group should have.

target_capacity str

The desired number of instances the group should have.

taskType String

The task type to run. Valid values: "setCapacity".

cronExpression String

A valid cron expression. The cron is running in UTC time zone and is in Unix cron format.

isEnabled Boolean

Setting the task to being enabled or disabled.

maxCapacity String

The maximum number of instances the group should have.

Usage:

import * as pulumi from "@pulumi/pulumi";
import pulumi
using System.Collections.Generic;
using System.Linq;
using Pulumi;

return await Deployment.RunAsync(() => { });

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}
{}
minCapacity String

The minimum number of instances the group should have.

targetCapacity String

The desired number of instances the group should have.

ElastigroupSubnet

Region string

The region for the group of subnets.

SubnetNames List<string>

The names of the subnets in the region.

Region string

The region for the group of subnets.

SubnetNames []string

The names of the subnets in the region.

region String

The region for the group of subnets.

subnetNames List<String>

The names of the subnets in the region.

region string

The region for the group of subnets.

subnetNames string[]

The names of the subnets in the region.

region str

The region for the group of subnets.

subnet_names Sequence[str]

The names of the subnets in the region.

region String

The region for the group of subnets.

subnetNames List<String>

The names of the subnets in the region.

Package Details

Repository
Spotinst pulumi/pulumi-spotinst
License
Apache-2.0
Notes

This Pulumi package is based on the spotinst Terraform Provider.