1. Packages
  2. Spotinst
  3. API Docs
  4. gcp
  5. Elastigroup
Spotinst v3.54.0 published on Friday, Sep 29, 2023 by Pulumi

spotinst.gcp.Elastigroup

Explore with Pulumi AI

spotinst logo
Spotinst v3.54.0 published on Friday, Sep 29, 2023 by Pulumi

    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.ElastigroupBackendService>
    Description string

    The region your GCP group will be created in.

    Disks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupDisk>
    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.ElastigroupGpu>
    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.ElastigroupInstanceTypesCustom>

    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.ElastigroupIntegrationDockerSwarm

    Describes the Docker Swarm integration.

    IntegrationGke Pulumi.SpotInst.Gcp.Inputs.ElastigroupIntegrationGke
    IpForwarding bool
    Labels List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupLabel>

    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.ElastigroupMetadata>

    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.ElastigroupNetworkInterface>

    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.ElastigroupScalingDownPolicy>

    Contains scaling policies for scaling the Elastigroup down.

    Each scaling_*_policy supports the following:

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

    Contains scaling policies for scaling the Elastigroup up.

    ScheduledTasks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScheduledTask>
    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.ElastigroupSubnet>

    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<ElastigroupBackendService>
    description String

    The region your GCP group will be created in.

    disks List<ElastigroupDisk>
    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<ElastigroupGpu>
    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<ElastigroupInstanceTypesCustom>

    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 ElastigroupIntegrationDockerSwarm

    Describes the Docker Swarm integration.

    integrationGke ElastigroupIntegrationGke
    ipForwarding Boolean
    labels List<ElastigroupLabel>

    Array of objects with key-value pairs.

    maxSize Integer

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

    metadatas List<ElastigroupMetadata>

    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<ElastigroupNetworkInterface>

    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<ElastigroupScalingDownPolicy>

    Contains scaling policies for scaling the Elastigroup down.

    Each scaling_*_policy supports the following:

    scalingUpPolicies List<ElastigroupScalingUpPolicy>

    Contains scaling policies for scaling the Elastigroup up.

    scheduledTasks List<ElastigroupScheduledTask>
    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<ElastigroupSubnet>

    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 ElastigroupBackendService[]
    description string

    The region your GCP group will be created in.

    disks ElastigroupDisk[]
    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 ElastigroupGpu[]
    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 ElastigroupInstanceTypesCustom[]

    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 ElastigroupIntegrationDockerSwarm

    Describes the Docker Swarm integration.

    integrationGke ElastigroupIntegrationGke
    ipForwarding boolean
    labels ElastigroupLabel[]

    Array of objects with key-value pairs.

    maxSize number

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

    metadatas ElastigroupMetadata[]

    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 ElastigroupNetworkInterface[]

    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 ElastigroupScalingDownPolicy[]

    Contains scaling policies for scaling the Elastigroup down.

    Each scaling_*_policy supports the following:

    scalingUpPolicies ElastigroupScalingUpPolicy[]

    Contains scaling policies for scaling the Elastigroup up.

    scheduledTasks ElastigroupScheduledTask[]
    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 ElastigroupSubnet[]

    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.ElastigroupBackendService>
    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.ElastigroupDisk>
    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.ElastigroupGpu>
    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.ElastigroupInstanceTypesCustom>

    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.ElastigroupIntegrationDockerSwarm

    Describes the Docker Swarm integration.

    IntegrationGke Pulumi.SpotInst.Gcp.Inputs.ElastigroupIntegrationGke
    IpForwarding bool
    Labels List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupLabel>

    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.ElastigroupMetadata>

    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.ElastigroupNetworkInterface>

    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.ElastigroupScalingDownPolicy>

    Contains scaling policies for scaling the Elastigroup down.

    Each scaling_*_policy supports the following:

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

    Contains scaling policies for scaling the Elastigroup up.

    ScheduledTasks List<Pulumi.SpotInst.Gcp.Inputs.ElastigroupScheduledTask>
    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.ElastigroupSubnet>

    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<ElastigroupBackendService>
    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<ElastigroupDisk>
    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<ElastigroupGpu>
    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<ElastigroupInstanceTypesCustom>

    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 ElastigroupIntegrationDockerSwarm

    Describes the Docker Swarm integration.

    integrationGke ElastigroupIntegrationGke
    ipForwarding Boolean
    labels List<ElastigroupLabel>

    Array of objects with key-value pairs.

    maxSize Integer

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

    metadatas List<ElastigroupMetadata>

    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<ElastigroupNetworkInterface>

    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<ElastigroupScalingDownPolicy>

    Contains scaling policies for scaling the Elastigroup down.

    Each scaling_*_policy supports the following:

    scalingUpPolicies List<ElastigroupScalingUpPolicy>

    Contains scaling policies for scaling the Elastigroup up.

    scheduledTasks List<ElastigroupScheduledTask>
    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<ElastigroupSubnet>

    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 ElastigroupBackendService[]
    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 ElastigroupDisk[]
    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 ElastigroupGpu[]
    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 ElastigroupInstanceTypesCustom[]

    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 ElastigroupIntegrationDockerSwarm

    Describes the Docker Swarm integration.

    integrationGke ElastigroupIntegrationGke
    ipForwarding boolean
    labels ElastigroupLabel[]

    Array of objects with key-value pairs.

    maxSize number

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

    metadatas ElastigroupMetadata[]

    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 ElastigroupNetworkInterface[]

    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 ElastigroupScalingDownPolicy[]

    Contains scaling policies for scaling the Elastigroup down.

    Each scaling_*_policy supports the following:

    scalingUpPolicies ElastigroupScalingUpPolicy[]

    Contains scaling policies for scaling the Elastigroup up.

    scheduledTasks ElastigroupScheduledTask[]
    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 ElastigroupSubnet[]

    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, ElastigroupBackendServiceArgs

    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, ElastigroupBackendServiceNamedPortArgs

    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, ElastigroupDiskArgs

    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, ElastigroupDiskInitializeParamArgs

    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, ElastigroupGpuArgs

    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, ElastigroupInstanceTypesCustomArgs

    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, ElastigroupIntegrationDockerSwarmArgs

    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, ElastigroupIntegrationGkeArgs

    ElastigroupIntegrationGkeAutoscaleDown, ElastigroupIntegrationGkeAutoscaleDownArgs

    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, ElastigroupIntegrationGkeAutoscaleHeadroomArgs

    cpuPerUnit Integer
    memoryPerUnit Integer
    numOfUnits Integer

    ElastigroupIntegrationGkeAutoscaleLabel, ElastigroupIntegrationGkeAutoscaleLabelArgs

    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, ElastigroupLabelArgs

    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, ElastigroupMetadataArgs

    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, ElastigroupNetworkInterfaceArgs

    network String

    Network resource for this group.

    accessConfigs List<Property Map>

    Array of configurations.

    aliasIpRanges List<Property Map>

    ElastigroupNetworkInterfaceAccessConfig, ElastigroupNetworkInterfaceAccessConfigArgs

    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, ElastigroupNetworkInterfaceAliasIpRangeArgs

    ElastigroupScalingDownPolicy, ElastigroupScalingDownPolicyArgs

    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, ElastigroupScalingDownPolicyDimensionArgs

    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, ElastigroupScalingUpPolicyArgs

    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, ElastigroupScalingUpPolicyDimensionArgs

    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, ElastigroupScheduledTaskArgs

    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, ElastigroupSubnetArgs

    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.

    spotinst logo
    Spotinst v3.54.0 published on Friday, Sep 29, 2023 by Pulumi