Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi IDP Pulumi Cloud Packages Tutorials
  1. Packages
  2. Scaleway
  3. API Docs
  4. autoscaling
  5. InstanceGroup
Scaleway v1.32.0 published on Friday, Aug 1, 2025 by pulumiverse
pulumiverse/pulumi-scaleway

scaleway.autoscaling.InstanceGroup

Explore with Pulumi AI

scaleway logo
Scaleway v1.32.0 published on Friday, Aug 1, 2025 by pulumiverse
pulumiverse/pulumi-scaleway

    Books and manages Autoscaling Instance groups.

    Example Usage

    Basic

    import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.autoscaling.InstanceGroup("main", {
    name: "asg-group",
    templateId: mainScalewayAutoscalingInstanceTemplate.id,
    tags: [
        "terraform-test",
        "instance-group",
    ],
    capacities: [{
        maxReplicas: 5,
        minReplicas: 1,
        cooldownDelay: 300,
    }],
    loadBalancers: [{
        id: mainScalewayLb.id,
        backendIds: [mainScalewayLbBackend.id],
        privateNetworkId: mainScalewayVpcPrivateNetwork.id,
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

main = scaleway.autoscaling.InstanceGroup("main",
    name="asg-group",
    template_id=main_scaleway_autoscaling_instance_template["id"],
    tags=[
        "terraform-test",
        "instance-group",
    ],
    capacities=[{
        "max_replicas": 5,
        "min_replicas": 1,
        "cooldown_delay": 300,
    }],
    load_balancers=[{
        "id": main_scaleway_lb["id"],
        "backend_ids": [main_scaleway_lb_backend["id"]],
        "private_network_id": main_scaleway_vpc_private_network["id"],
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/autoscaling"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := autoscaling.NewInstanceGroup(ctx, "main", &autoscaling.InstanceGroupArgs{
			Name:       pulumi.String("asg-group"),
			TemplateId: pulumi.Any(mainScalewayAutoscalingInstanceTemplate.Id),
			Tags: pulumi.StringArray{
				pulumi.String("terraform-test"),
				pulumi.String("instance-group"),
			},
			Capacities: autoscaling.InstanceGroupCapacityArray{
				&autoscaling.InstanceGroupCapacityArgs{
					MaxReplicas:   pulumi.Int(5),
					MinReplicas:   pulumi.Int(1),
					CooldownDelay: pulumi.Int(300),
				},
			},
			LoadBalancers: autoscaling.InstanceGroupLoadBalancerArray{
				&autoscaling.InstanceGroupLoadBalancerArgs{
					Id: pulumi.Any(mainScalewayLb.Id),
					BackendIds: pulumi.StringArray{
						mainScalewayLbBackend.Id,
					},
					PrivateNetworkId: pulumi.Any(mainScalewayVpcPrivateNetwork.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Autoscaling.InstanceGroup("main", new()
    {
        Name = "asg-group",
        TemplateId = mainScalewayAutoscalingInstanceTemplate.Id,
        Tags = new[]
        {
            "terraform-test",
            "instance-group",
        },
        Capacities = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstanceGroupCapacityArgs
            {
                MaxReplicas = 5,
                MinReplicas = 1,
                CooldownDelay = 300,
            },
        },
        LoadBalancers = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstanceGroupLoadBalancerArgs
            {
                Id = mainScalewayLb.Id,
                BackendIds = new[]
                {
                    mainScalewayLbBackend.Id,
                },
                PrivateNetworkId = mainScalewayVpcPrivateNetwork.Id,
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.autoscaling.InstanceGroup;
import com.pulumi.scaleway.autoscaling.InstanceGroupArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstanceGroupCapacityArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstanceGroupLoadBalancerArgs;
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 main = new InstanceGroup("main", InstanceGroupArgs.builder()
            .name("asg-group")
            .templateId(mainScalewayAutoscalingInstanceTemplate.id())
            .tags(            
                "terraform-test",
                "instance-group")
            .capacities(InstanceGroupCapacityArgs.builder()
                .maxReplicas(5)
                .minReplicas(1)
                .cooldownDelay(300)
                .build())
            .loadBalancers(InstanceGroupLoadBalancerArgs.builder()
                .id(mainScalewayLb.id())
                .backendIds(mainScalewayLbBackend.id())
                .privateNetworkId(mainScalewayVpcPrivateNetwork.id())
                .build())
            .build());

    }
}

    resources:
  main:
    type: scaleway:autoscaling:InstanceGroup
    properties:
      name: asg-group
      templateId: ${mainScalewayAutoscalingInstanceTemplate.id}
      tags:
        - terraform-test
        - instance-group
      capacities:
        - maxReplicas: 5
          minReplicas: 1
          cooldownDelay: '300'
      loadBalancers:
        - id: ${mainScalewayLb.id}
          backendIds:
            - ${mainScalewayLbBackend.id}
          privateNetworkId: ${mainScalewayVpcPrivateNetwork.id}

    With template and policies

    import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.network.Vpc("main", {name: "TestAccAutoscalingVPC"});
const mainPrivateNetwork = new scaleway.network.PrivateNetwork("main", {
    name: "TestAccAutoscalingVPC",
    vpcId: main.id,
});
const mainVolume = new scaleway.block.Volume("main", {
    iops: 5000,
    sizeInGb: 10,
});
const mainSnapshot = new scaleway.block.Snapshot("main", {
    name: "test-ds-block-snapshot-basic",
    volumeId: mainVolume.id,
});
const mainIp = new scaleway.loadbalancers.Ip("main", {});
const mainLoadBalancer = new scaleway.loadbalancers.LoadBalancer("main", {
    ipId: mainIp.id,
    name: "test-lb",
    type: "lb-s",
    privateNetworks: [{
        privateNetworkId: mainPrivateNetwork.id,
    }],
});
const mainBackend = new scaleway.loadbalancers.Backend("main", {
    lbId: mainLoadBalancer.id,
    forwardProtocol: "tcp",
    forwardPort: 80,
    proxyProtocol: "none",
});
const mainInstanceTemplate = new scaleway.autoscaling.InstanceTemplate("main", {
    name: "autoscaling-instance-template-basic",
    commercialType: "PLAY2-MICRO",
    tags: [
        "terraform-test",
        "basic",
    ],
    volumes: [{
        name: "as-volume",
        volumeType: "sbs",
        boot: true,
        fromSnapshot: {
            snapshotId: mainSnapshot.id,
        },
        perfIops: 5000,
    }],
    publicIpsV4Count: 1,
    privateNetworkIds: [mainPrivateNetwork.id],
});
const mainInstanceGroup = new scaleway.autoscaling.InstanceGroup("main", {
    name: "autoscaling-instance-group-basic",
    templateId: mainInstanceTemplate.id,
    tags: [
        "terraform-test",
        "instance-group",
    ],
    capacities: [{
        maxReplicas: 5,
        minReplicas: 1,
        cooldownDelay: 300,
    }],
    loadBalancers: [{
        id: mainLoadBalancer.id,
        backendIds: [mainBackend.id],
        privateNetworkId: mainPrivateNetwork.id,
    }],
    deleteServersOnDestroy: true,
});
const up = new scaleway.autoscaling.InstancePolicy("up", {
    instanceGroupId: mainInstanceGroup.id,
    name: "scale-up-if-cpu-high",
    action: "scale_up",
    type: "flat_count",
    value: 1,
    priority: 1,
    metrics: [{
        name: "cpu scale up",
        managedMetric: "managed_metric_instance_cpu",
        operator: "operator_greater_than",
        aggregate: "aggregate_average",
        samplingRangeMin: 5,
        threshold: 70,
    }],
});
const down = new scaleway.autoscaling.InstancePolicy("down", {
    instanceGroupId: mainInstanceGroup.id,
    name: "scale-down-if-cpu-low",
    action: "scale_down",
    type: "flat_count",
    value: 1,
    priority: 2,
    metrics: [{
        name: "cpu scale down",
        managedMetric: "managed_metric_instance_cpu",
        operator: "operator_less_than",
        aggregate: "aggregate_average",
        samplingRangeMin: 5,
        threshold: 40,
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

main = scaleway.network.Vpc("main", name="TestAccAutoscalingVPC")
main_private_network = scaleway.network.PrivateNetwork("main",
    name="TestAccAutoscalingVPC",
    vpc_id=main.id)
main_volume = scaleway.block.Volume("main",
    iops=5000,
    size_in_gb=10)
main_snapshot = scaleway.block.Snapshot("main",
    name="test-ds-block-snapshot-basic",
    volume_id=main_volume.id)
main_ip = scaleway.loadbalancers.Ip("main")
main_load_balancer = scaleway.loadbalancers.LoadBalancer("main",
    ip_id=main_ip.id,
    name="test-lb",
    type="lb-s",
    private_networks=[{
        "private_network_id": main_private_network.id,
    }])
main_backend = scaleway.loadbalancers.Backend("main",
    lb_id=main_load_balancer.id,
    forward_protocol="tcp",
    forward_port=80,
    proxy_protocol="none")
main_instance_template = scaleway.autoscaling.InstanceTemplate("main",
    name="autoscaling-instance-template-basic",
    commercial_type="PLAY2-MICRO",
    tags=[
        "terraform-test",
        "basic",
    ],
    volumes=[{
        "name": "as-volume",
        "volume_type": "sbs",
        "boot": True,
        "from_snapshot": {
            "snapshot_id": main_snapshot.id,
        },
        "perf_iops": 5000,
    }],
    public_ips_v4_count=1,
    private_network_ids=[main_private_network.id])
main_instance_group = scaleway.autoscaling.InstanceGroup("main",
    name="autoscaling-instance-group-basic",
    template_id=main_instance_template.id,
    tags=[
        "terraform-test",
        "instance-group",
    ],
    capacities=[{
        "max_replicas": 5,
        "min_replicas": 1,
        "cooldown_delay": 300,
    }],
    load_balancers=[{
        "id": main_load_balancer.id,
        "backend_ids": [main_backend.id],
        "private_network_id": main_private_network.id,
    }],
    delete_servers_on_destroy=True)
up = scaleway.autoscaling.InstancePolicy("up",
    instance_group_id=main_instance_group.id,
    name="scale-up-if-cpu-high",
    action="scale_up",
    type="flat_count",
    value=1,
    priority=1,
    metrics=[{
        "name": "cpu scale up",
        "managed_metric": "managed_metric_instance_cpu",
        "operator": "operator_greater_than",
        "aggregate": "aggregate_average",
        "sampling_range_min": 5,
        "threshold": 70,
    }])
down = scaleway.autoscaling.InstancePolicy("down",
    instance_group_id=main_instance_group.id,
    name="scale-down-if-cpu-low",
    action="scale_down",
    type="flat_count",
    value=1,
    priority=2,
    metrics=[{
        "name": "cpu scale down",
        "managed_metric": "managed_metric_instance_cpu",
        "operator": "operator_less_than",
        "aggregate": "aggregate_average",
        "sampling_range_min": 5,
        "threshold": 40,
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/autoscaling"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/block"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/loadbalancers"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/network"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := network.NewVpc(ctx, "main", &network.VpcArgs{
			Name: pulumi.String("TestAccAutoscalingVPC"),
		})
		if err != nil {
			return err
		}
		mainPrivateNetwork, err := network.NewPrivateNetwork(ctx, "main", &network.PrivateNetworkArgs{
			Name:  pulumi.String("TestAccAutoscalingVPC"),
			VpcId: main.ID(),
		})
		if err != nil {
			return err
		}
		mainVolume, err := block.NewVolume(ctx, "main", &block.VolumeArgs{
			Iops:     pulumi.Int(5000),
			SizeInGb: pulumi.Int(10),
		})
		if err != nil {
			return err
		}
		mainSnapshot, err := block.NewSnapshot(ctx, "main", &block.SnapshotArgs{
			Name:     pulumi.String("test-ds-block-snapshot-basic"),
			VolumeId: mainVolume.ID(),
		})
		if err != nil {
			return err
		}
		mainIp, err := loadbalancers.NewIp(ctx, "main", nil)
		if err != nil {
			return err
		}
		mainLoadBalancer, err := loadbalancers.NewLoadBalancer(ctx, "main", &loadbalancers.LoadBalancerArgs{
			IpId: mainIp.ID(),
			Name: pulumi.String("test-lb"),
			Type: pulumi.String("lb-s"),
			PrivateNetworks: loadbalancers.LoadBalancerPrivateNetworkArray{
				&loadbalancers.LoadBalancerPrivateNetworkArgs{
					PrivateNetworkId: mainPrivateNetwork.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		mainBackend, err := loadbalancers.NewBackend(ctx, "main", &loadbalancers.BackendArgs{
			LbId:            mainLoadBalancer.ID(),
			ForwardProtocol: pulumi.String("tcp"),
			ForwardPort:     pulumi.Int(80),
			ProxyProtocol:   pulumi.String("none"),
		})
		if err != nil {
			return err
		}
		mainInstanceTemplate, err := autoscaling.NewInstanceTemplate(ctx, "main", &autoscaling.InstanceTemplateArgs{
			Name:           pulumi.String("autoscaling-instance-template-basic"),
			CommercialType: pulumi.String("PLAY2-MICRO"),
			Tags: pulumi.StringArray{
				pulumi.String("terraform-test"),
				pulumi.String("basic"),
			},
			Volumes: autoscaling.InstanceTemplateVolumeArray{
				&autoscaling.InstanceTemplateVolumeArgs{
					Name:       pulumi.String("as-volume"),
					VolumeType: pulumi.String("sbs"),
					Boot:       pulumi.Bool(true),
					FromSnapshot: &autoscaling.InstanceTemplateVolumeFromSnapshotArgs{
						SnapshotId: mainSnapshot.ID(),
					},
					PerfIops: pulumi.Int(5000),
				},
			},
			PublicIpsV4Count: pulumi.Int(1),
			PrivateNetworkIds: pulumi.StringArray{
				mainPrivateNetwork.ID(),
			},
		})
		if err != nil {
			return err
		}
		mainInstanceGroup, err := autoscaling.NewInstanceGroup(ctx, "main", &autoscaling.InstanceGroupArgs{
			Name:       pulumi.String("autoscaling-instance-group-basic"),
			TemplateId: mainInstanceTemplate.ID(),
			Tags: pulumi.StringArray{
				pulumi.String("terraform-test"),
				pulumi.String("instance-group"),
			},
			Capacities: autoscaling.InstanceGroupCapacityArray{
				&autoscaling.InstanceGroupCapacityArgs{
					MaxReplicas:   pulumi.Int(5),
					MinReplicas:   pulumi.Int(1),
					CooldownDelay: pulumi.Int(300),
				},
			},
			LoadBalancers: autoscaling.InstanceGroupLoadBalancerArray{
				&autoscaling.InstanceGroupLoadBalancerArgs{
					Id: mainLoadBalancer.ID(),
					BackendIds: pulumi.StringArray{
						mainBackend.ID(),
					},
					PrivateNetworkId: mainPrivateNetwork.ID(),
				},
			},
			DeleteServersOnDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewInstancePolicy(ctx, "up", &autoscaling.InstancePolicyArgs{
			InstanceGroupId: mainInstanceGroup.ID(),
			Name:            pulumi.String("scale-up-if-cpu-high"),
			Action:          pulumi.String("scale_up"),
			Type:            pulumi.String("flat_count"),
			Value:           pulumi.Int(1),
			Priority:        pulumi.Int(1),
			Metrics: autoscaling.InstancePolicyMetricArray{
				&autoscaling.InstancePolicyMetricArgs{
					Name:             pulumi.String("cpu scale up"),
					ManagedMetric:    pulumi.String("managed_metric_instance_cpu"),
					Operator:         pulumi.String("operator_greater_than"),
					Aggregate:        pulumi.String("aggregate_average"),
					SamplingRangeMin: pulumi.Int(5),
					Threshold:        pulumi.Int(70),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewInstancePolicy(ctx, "down", &autoscaling.InstancePolicyArgs{
			InstanceGroupId: mainInstanceGroup.ID(),
			Name:            pulumi.String("scale-down-if-cpu-low"),
			Action:          pulumi.String("scale_down"),
			Type:            pulumi.String("flat_count"),
			Value:           pulumi.Int(1),
			Priority:        pulumi.Int(2),
			Metrics: autoscaling.InstancePolicyMetricArray{
				&autoscaling.InstancePolicyMetricArgs{
					Name:             pulumi.String("cpu scale down"),
					ManagedMetric:    pulumi.String("managed_metric_instance_cpu"),
					Operator:         pulumi.String("operator_less_than"),
					Aggregate:        pulumi.String("aggregate_average"),
					SamplingRangeMin: pulumi.Int(5),
					Threshold:        pulumi.Int(40),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Network.Vpc("main", new()
    {
        Name = "TestAccAutoscalingVPC",
    });

    var mainPrivateNetwork = new Scaleway.Network.PrivateNetwork("main", new()
    {
        Name = "TestAccAutoscalingVPC",
        VpcId = main.Id,
    });

    var mainVolume = new Scaleway.Block.Volume("main", new()
    {
        Iops = 5000,
        SizeInGb = 10,
    });

    var mainSnapshot = new Scaleway.Block.Snapshot("main", new()
    {
        Name = "test-ds-block-snapshot-basic",
        VolumeId = mainVolume.Id,
    });

    var mainIp = new Scaleway.Loadbalancers.Ip("main");

    var mainLoadBalancer = new Scaleway.Loadbalancers.LoadBalancer("main", new()
    {
        IpId = mainIp.Id,
        Name = "test-lb",
        Type = "lb-s",
        PrivateNetworks = new[]
        {
            new Scaleway.Loadbalancers.Inputs.LoadBalancerPrivateNetworkArgs
            {
                PrivateNetworkId = mainPrivateNetwork.Id,
            },
        },
    });

    var mainBackend = new Scaleway.Loadbalancers.Backend("main", new()
    {
        LbId = mainLoadBalancer.Id,
        ForwardProtocol = "tcp",
        ForwardPort = 80,
        ProxyProtocol = "none",
    });

    var mainInstanceTemplate = new Scaleway.Autoscaling.InstanceTemplate("main", new()
    {
        Name = "autoscaling-instance-template-basic",
        CommercialType = "PLAY2-MICRO",
        Tags = new[]
        {
            "terraform-test",
            "basic",
        },
        Volumes = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstanceTemplateVolumeArgs
            {
                Name = "as-volume",
                VolumeType = "sbs",
                Boot = true,
                FromSnapshot = new Scaleway.Autoscaling.Inputs.InstanceTemplateVolumeFromSnapshotArgs
                {
                    SnapshotId = mainSnapshot.Id,
                },
                PerfIops = 5000,
            },
        },
        PublicIpsV4Count = 1,
        PrivateNetworkIds = new[]
        {
            mainPrivateNetwork.Id,
        },
    });

    var mainInstanceGroup = new Scaleway.Autoscaling.InstanceGroup("main", new()
    {
        Name = "autoscaling-instance-group-basic",
        TemplateId = mainInstanceTemplate.Id,
        Tags = new[]
        {
            "terraform-test",
            "instance-group",
        },
        Capacities = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstanceGroupCapacityArgs
            {
                MaxReplicas = 5,
                MinReplicas = 1,
                CooldownDelay = 300,
            },
        },
        LoadBalancers = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstanceGroupLoadBalancerArgs
            {
                Id = mainLoadBalancer.Id,
                BackendIds = new[]
                {
                    mainBackend.Id,
                },
                PrivateNetworkId = mainPrivateNetwork.Id,
            },
        },
        DeleteServersOnDestroy = true,
    });

    var up = new Scaleway.Autoscaling.InstancePolicy("up", new()
    {
        InstanceGroupId = mainInstanceGroup.Id,
        Name = "scale-up-if-cpu-high",
        Action = "scale_up",
        Type = "flat_count",
        Value = 1,
        Priority = 1,
        Metrics = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstancePolicyMetricArgs
            {
                Name = "cpu scale up",
                ManagedMetric = "managed_metric_instance_cpu",
                Operator = "operator_greater_than",
                Aggregate = "aggregate_average",
                SamplingRangeMin = 5,
                Threshold = 70,
            },
        },
    });

    var down = new Scaleway.Autoscaling.InstancePolicy("down", new()
    {
        InstanceGroupId = mainInstanceGroup.Id,
        Name = "scale-down-if-cpu-low",
        Action = "scale_down",
        Type = "flat_count",
        Value = 1,
        Priority = 2,
        Metrics = new[]
        {
            new Scaleway.Autoscaling.Inputs.InstancePolicyMetricArgs
            {
                Name = "cpu scale down",
                ManagedMetric = "managed_metric_instance_cpu",
                Operator = "operator_less_than",
                Aggregate = "aggregate_average",
                SamplingRangeMin = 5,
                Threshold = 40,
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.network.Vpc;
import com.pulumi.scaleway.network.VpcArgs;
import com.pulumi.scaleway.network.PrivateNetwork;
import com.pulumi.scaleway.network.PrivateNetworkArgs;
import com.pulumi.scaleway.block.Volume;
import com.pulumi.scaleway.block.VolumeArgs;
import com.pulumi.scaleway.block.Snapshot;
import com.pulumi.scaleway.block.SnapshotArgs;
import com.pulumi.scaleway.loadbalancers.Ip;
import com.pulumi.scaleway.loadbalancers.LoadBalancer;
import com.pulumi.scaleway.loadbalancers.LoadBalancerArgs;
import com.pulumi.scaleway.loadbalancers.inputs.LoadBalancerPrivateNetworkArgs;
import com.pulumi.scaleway.loadbalancers.Backend;
import com.pulumi.scaleway.loadbalancers.BackendArgs;
import com.pulumi.scaleway.autoscaling.InstanceTemplate;
import com.pulumi.scaleway.autoscaling.InstanceTemplateArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstanceTemplateVolumeArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstanceTemplateVolumeFromSnapshotArgs;
import com.pulumi.scaleway.autoscaling.InstanceGroup;
import com.pulumi.scaleway.autoscaling.InstanceGroupArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstanceGroupCapacityArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstanceGroupLoadBalancerArgs;
import com.pulumi.scaleway.autoscaling.InstancePolicy;
import com.pulumi.scaleway.autoscaling.InstancePolicyArgs;
import com.pulumi.scaleway.autoscaling.inputs.InstancePolicyMetricArgs;
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 main = new Vpc("main", VpcArgs.builder()
            .name("TestAccAutoscalingVPC")
            .build());

        var mainPrivateNetwork = new PrivateNetwork("mainPrivateNetwork", PrivateNetworkArgs.builder()
            .name("TestAccAutoscalingVPC")
            .vpcId(main.id())
            .build());

        var mainVolume = new Volume("mainVolume", VolumeArgs.builder()
            .iops(5000)
            .sizeInGb(10)
            .build());

        var mainSnapshot = new Snapshot("mainSnapshot", SnapshotArgs.builder()
            .name("test-ds-block-snapshot-basic")
            .volumeId(mainVolume.id())
            .build());

        var mainIp = new Ip("mainIp");

        var mainLoadBalancer = new LoadBalancer("mainLoadBalancer", LoadBalancerArgs.builder()
            .ipId(mainIp.id())
            .name("test-lb")
            .type("lb-s")
            .privateNetworks(LoadBalancerPrivateNetworkArgs.builder()
                .privateNetworkId(mainPrivateNetwork.id())
                .build())
            .build());

        var mainBackend = new Backend("mainBackend", BackendArgs.builder()
            .lbId(mainLoadBalancer.id())
            .forwardProtocol("tcp")
            .forwardPort(80)
            .proxyProtocol("none")
            .build());

        var mainInstanceTemplate = new InstanceTemplate("mainInstanceTemplate", InstanceTemplateArgs.builder()
            .name("autoscaling-instance-template-basic")
            .commercialType("PLAY2-MICRO")
            .tags(            
                "terraform-test",
                "basic")
            .volumes(InstanceTemplateVolumeArgs.builder()
                .name("as-volume")
                .volumeType("sbs")
                .boot(true)
                .fromSnapshot(InstanceTemplateVolumeFromSnapshotArgs.builder()
                    .snapshotId(mainSnapshot.id())
                    .build())
                .perfIops(5000)
                .build())
            .publicIpsV4Count(1)
            .privateNetworkIds(mainPrivateNetwork.id())
            .build());

        var mainInstanceGroup = new InstanceGroup("mainInstanceGroup", InstanceGroupArgs.builder()
            .name("autoscaling-instance-group-basic")
            .templateId(mainInstanceTemplate.id())
            .tags(            
                "terraform-test",
                "instance-group")
            .capacities(InstanceGroupCapacityArgs.builder()
                .maxReplicas(5)
                .minReplicas(1)
                .cooldownDelay(300)
                .build())
            .loadBalancers(InstanceGroupLoadBalancerArgs.builder()
                .id(mainLoadBalancer.id())
                .backendIds(mainBackend.id())
                .privateNetworkId(mainPrivateNetwork.id())
                .build())
            .deleteServersOnDestroy(true)
            .build());

        var up = new InstancePolicy("up", InstancePolicyArgs.builder()
            .instanceGroupId(mainInstanceGroup.id())
            .name("scale-up-if-cpu-high")
            .action("scale_up")
            .type("flat_count")
            .value(1)
            .priority(1)
            .metrics(InstancePolicyMetricArgs.builder()
                .name("cpu scale up")
                .managedMetric("managed_metric_instance_cpu")
                .operator("operator_greater_than")
                .aggregate("aggregate_average")
                .samplingRangeMin(5)
                .threshold(70)
                .build())
            .build());

        var down = new InstancePolicy("down", InstancePolicyArgs.builder()
            .instanceGroupId(mainInstanceGroup.id())
            .name("scale-down-if-cpu-low")
            .action("scale_down")
            .type("flat_count")
            .value(1)
            .priority(2)
            .metrics(InstancePolicyMetricArgs.builder()
                .name("cpu scale down")
                .managedMetric("managed_metric_instance_cpu")
                .operator("operator_less_than")
                .aggregate("aggregate_average")
                .samplingRangeMin(5)
                .threshold(40)
                .build())
            .build());

    }
}

    resources:
  main:
    type: scaleway:network:Vpc
    properties:
      name: TestAccAutoscalingVPC
  mainPrivateNetwork:
    type: scaleway:network:PrivateNetwork
    name: main
    properties:
      name: TestAccAutoscalingVPC
      vpcId: ${main.id}
  mainVolume:
    type: scaleway:block:Volume
    name: main
    properties:
      iops: 5000
      sizeInGb: 10
  mainSnapshot:
    type: scaleway:block:Snapshot
    name: main
    properties:
      name: test-ds-block-snapshot-basic
      volumeId: ${mainVolume.id}
  mainIp:
    type: scaleway:loadbalancers:Ip
    name: main
  mainLoadBalancer:
    type: scaleway:loadbalancers:LoadBalancer
    name: main
    properties:
      ipId: ${mainIp.id}
      name: test-lb
      type: lb-s
      privateNetworks:
        - privateNetworkId: ${mainPrivateNetwork.id}
  mainBackend:
    type: scaleway:loadbalancers:Backend
    name: main
    properties:
      lbId: ${mainLoadBalancer.id}
      forwardProtocol: tcp
      forwardPort: 80
      proxyProtocol: none
  mainInstanceTemplate:
    type: scaleway:autoscaling:InstanceTemplate
    name: main
    properties:
      name: autoscaling-instance-template-basic
      commercialType: PLAY2-MICRO
      tags:
        - terraform-test
        - basic
      volumes:
        - name: as-volume
          volumeType: sbs
          boot: true
          fromSnapshot:
            snapshotId: ${mainSnapshot.id}
          perfIops: 5000
      publicIpsV4Count: 1
      privateNetworkIds:
        - ${mainPrivateNetwork.id}
  mainInstanceGroup:
    type: scaleway:autoscaling:InstanceGroup
    name: main
    properties:
      name: autoscaling-instance-group-basic
      templateId: ${mainInstanceTemplate.id}
      tags:
        - terraform-test
        - instance-group
      capacities:
        - maxReplicas: 5
          minReplicas: 1
          cooldownDelay: '300'
      loadBalancers:
        - id: ${mainLoadBalancer.id}
          backendIds:
            - ${mainBackend.id}
          privateNetworkId: ${mainPrivateNetwork.id}
      deleteServersOnDestroy: true
  up:
    type: scaleway:autoscaling:InstancePolicy
    properties:
      instanceGroupId: ${mainInstanceGroup.id}
      name: scale-up-if-cpu-high
      action: scale_up
      type: flat_count
      value: 1
      priority: 1
      metrics:
        - name: cpu scale up
          managedMetric: managed_metric_instance_cpu
          operator: operator_greater_than
          aggregate: aggregate_average
          samplingRangeMin: 5
          threshold: 70
  down:
    type: scaleway:autoscaling:InstancePolicy
    properties:
      instanceGroupId: ${mainInstanceGroup.id}
      name: scale-down-if-cpu-low
      action: scale_down
      type: flat_count
      value: 1
      priority: 2
      metrics:
        - name: cpu scale down
          managedMetric: managed_metric_instance_cpu
          operator: operator_less_than
          aggregate: aggregate_average
          samplingRangeMin: 5
          threshold: 40

    Create InstanceGroup Resource

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

    Constructor syntax

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

@overload
def InstanceGroup(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  template_id: Optional[str] = None,
                  capacities: Optional[Sequence[InstanceGroupCapacityArgs]] = None,
                  delete_servers_on_destroy: Optional[bool] = None,
                  load_balancers: Optional[Sequence[InstanceGroupLoadBalancerArgs]] = None,
                  name: Optional[str] = None,
                  project_id: Optional[str] = None,
                  tags: Optional[Sequence[str]] = None,
                  zone: Optional[str] = None)
    func NewInstanceGroup(ctx *Context, name string, args InstanceGroupArgs, opts ...ResourceOption) (*InstanceGroup, error)
    public InstanceGroup(string name, InstanceGroupArgs args, CustomResourceOptions? opts = null)
    public InstanceGroup(String name, InstanceGroupArgs args)
public InstanceGroup(String name, InstanceGroupArgs args, CustomResourceOptions options)

    type: scaleway:autoscaling:InstanceGroup
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

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

    Constructor example

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

    var instanceGroupResource = new Scaleway.Autoscaling.InstanceGroup("instanceGroupResource", new()
{
    TemplateId = "string",
    Capacities = new[]
    {
        new Scaleway.Autoscaling.Inputs.InstanceGroupCapacityArgs
        {
            CooldownDelay = 0,
            MaxReplicas = 0,
            MinReplicas = 0,
        },
    },
    DeleteServersOnDestroy = false,
    LoadBalancers = new[]
    {
        new Scaleway.Autoscaling.Inputs.InstanceGroupLoadBalancerArgs
        {
            BackendIds = new[]
            {
                "string",
            },
            Id = "string",
            PrivateNetworkId = "string",
        },
    },
    Name = "string",
    ProjectId = "string",
    Tags = new[]
    {
        "string",
    },
    Zone = "string",
});

    example, err := autoscaling.NewInstanceGroup(ctx, "instanceGroupResource", &autoscaling.InstanceGroupArgs{
	TemplateId: pulumi.String("string"),
	Capacities: autoscaling.InstanceGroupCapacityArray{
		&autoscaling.InstanceGroupCapacityArgs{
			CooldownDelay: pulumi.Int(0),
			MaxReplicas:   pulumi.Int(0),
			MinReplicas:   pulumi.Int(0),
		},
	},
	DeleteServersOnDestroy: pulumi.Bool(false),
	LoadBalancers: autoscaling.InstanceGroupLoadBalancerArray{
		&autoscaling.InstanceGroupLoadBalancerArgs{
			BackendIds: pulumi.StringArray{
				pulumi.String("string"),
			},
			Id:               pulumi.String("string"),
			PrivateNetworkId: pulumi.String("string"),
		},
	},
	Name:      pulumi.String("string"),
	ProjectId: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	Zone: pulumi.String("string"),
})

    var instanceGroupResource = new InstanceGroup("instanceGroupResource", InstanceGroupArgs.builder()
    .templateId("string")
    .capacities(InstanceGroupCapacityArgs.builder()
        .cooldownDelay(0)
        .maxReplicas(0)
        .minReplicas(0)
        .build())
    .deleteServersOnDestroy(false)
    .loadBalancers(InstanceGroupLoadBalancerArgs.builder()
        .backendIds("string")
        .id("string")
        .privateNetworkId("string")
        .build())
    .name("string")
    .projectId("string")
    .tags("string")
    .zone("string")
    .build());

    instance_group_resource = scaleway.autoscaling.InstanceGroup("instanceGroupResource",
    template_id="string",
    capacities=[{
        "cooldown_delay": 0,
        "max_replicas": 0,
        "min_replicas": 0,
    }],
    delete_servers_on_destroy=False,
    load_balancers=[{
        "backend_ids": ["string"],
        "id": "string",
        "private_network_id": "string",
    }],
    name="string",
    project_id="string",
    tags=["string"],
    zone="string")

    const instanceGroupResource = new scaleway.autoscaling.InstanceGroup("instanceGroupResource", {
    templateId: "string",
    capacities: [{
        cooldownDelay: 0,
        maxReplicas: 0,
        minReplicas: 0,
    }],
    deleteServersOnDestroy: false,
    loadBalancers: [{
        backendIds: ["string"],
        id: "string",
        privateNetworkId: "string",
    }],
    name: "string",
    projectId: "string",
    tags: ["string"],
    zone: "string",
});

    type: scaleway:autoscaling:InstanceGroup
properties:
    capacities:
        - cooldownDelay: 0
          maxReplicas: 0
          minReplicas: 0
    deleteServersOnDestroy: false
    loadBalancers:
        - backendIds:
            - string
          id: string
          privateNetworkId: string
    name: string
    projectId: string
    tags:
        - string
    templateId: string
    zone: string

    InstanceGroup Resource Properties

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

    Inputs

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

    The InstanceGroup resource accepts the following input properties:

    TemplateId string
    The ID of the Instance template to attach to the Instance group.
    Capacities List<Pulumiverse.Scaleway.Autoscaling.Inputs.InstanceGroupCapacity>
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    DeleteServersOnDestroy bool
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    LoadBalancers List<Pulumiverse.Scaleway.Autoscaling.Inputs.InstanceGroupLoadBalancer>
    The specification of the Load Balancer to link to the Instance group.
    Name string
    The Instance group name.
    ProjectId string
    project_id) The ID of the Project the Instance group is associated with.
    Tags List<string>
    The tags associated with the Instance group.
    Zone string
    zone) The zone in which the Instance group exists.
    TemplateId string
    The ID of the Instance template to attach to the Instance group.
    Capacities []InstanceGroupCapacityArgs
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    DeleteServersOnDestroy bool
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    LoadBalancers []InstanceGroupLoadBalancerArgs
    The specification of the Load Balancer to link to the Instance group.
    Name string
    The Instance group name.
    ProjectId string
    project_id) The ID of the Project the Instance group is associated with.
    Tags []string
    The tags associated with the Instance group.
    Zone string
    zone) The zone in which the Instance group exists.
    templateId String
    The ID of the Instance template to attach to the Instance group.
    capacities List<InstanceGroupCapacity>
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    deleteServersOnDestroy Boolean
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    loadBalancers List<InstanceGroupLoadBalancer>
    The specification of the Load Balancer to link to the Instance group.
    name String
    The Instance group name.
    projectId String
    project_id) The ID of the Project the Instance group is associated with.
    tags List<String>
    The tags associated with the Instance group.
    zone String
    zone) The zone in which the Instance group exists.
    templateId string
    The ID of the Instance template to attach to the Instance group.
    capacities InstanceGroupCapacity[]
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    deleteServersOnDestroy boolean
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    loadBalancers InstanceGroupLoadBalancer[]
    The specification of the Load Balancer to link to the Instance group.
    name string
    The Instance group name.
    projectId string
    project_id) The ID of the Project the Instance group is associated with.
    tags string[]
    The tags associated with the Instance group.
    zone string
    zone) The zone in which the Instance group exists.
    template_id str
    The ID of the Instance template to attach to the Instance group.
    capacities Sequence[InstanceGroupCapacityArgs]
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    delete_servers_on_destroy bool
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    load_balancers Sequence[InstanceGroupLoadBalancerArgs]
    The specification of the Load Balancer to link to the Instance group.
    name str
    The Instance group name.
    project_id str
    project_id) The ID of the Project the Instance group is associated with.
    tags Sequence[str]
    The tags associated with the Instance group.
    zone str
    zone) The zone in which the Instance group exists.
    templateId String
    The ID of the Instance template to attach to the Instance group.
    capacities List<Property Map>
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    deleteServersOnDestroy Boolean
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    loadBalancers List<Property Map>
    The specification of the Load Balancer to link to the Instance group.
    name String
    The Instance group name.
    projectId String
    project_id) The ID of the Project the Instance group is associated with.
    tags List<String>
    The tags associated with the Instance group.
    zone String
    zone) The zone in which the Instance group exists.

    Outputs

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

    CreatedAt string
    Date and time of Instance group's creation (RFC 3339 format).
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt string
    Date and time of Instance group's last update (RFC 3339 format).
    CreatedAt string
    Date and time of Instance group's creation (RFC 3339 format).
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt string
    Date and time of Instance group's last update (RFC 3339 format).
    createdAt String
    Date and time of Instance group's creation (RFC 3339 format).
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt String
    Date and time of Instance group's last update (RFC 3339 format).
    createdAt string
    Date and time of Instance group's creation (RFC 3339 format).
    id string
    The provider-assigned unique ID for this managed resource.
    updatedAt string
    Date and time of Instance group's last update (RFC 3339 format).
    created_at str
    Date and time of Instance group's creation (RFC 3339 format).
    id str
    The provider-assigned unique ID for this managed resource.
    updated_at str
    Date and time of Instance group's last update (RFC 3339 format).
    createdAt String
    Date and time of Instance group's creation (RFC 3339 format).
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt String
    Date and time of Instance group's last update (RFC 3339 format).

    Look up Existing InstanceGroup Resource

    Get an existing InstanceGroup 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?: InstanceGroupState, opts?: CustomResourceOptions): InstanceGroup
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        capacities: Optional[Sequence[InstanceGroupCapacityArgs]] = None,
        created_at: Optional[str] = None,
        delete_servers_on_destroy: Optional[bool] = None,
        load_balancers: Optional[Sequence[InstanceGroupLoadBalancerArgs]] = None,
        name: Optional[str] = None,
        project_id: Optional[str] = None,
        tags: Optional[Sequence[str]] = None,
        template_id: Optional[str] = None,
        updated_at: Optional[str] = None,
        zone: Optional[str] = None) -> InstanceGroup
    func GetInstanceGroup(ctx *Context, name string, id IDInput, state *InstanceGroupState, opts ...ResourceOption) (*InstanceGroup, error)
    public static InstanceGroup Get(string name, Input<string> id, InstanceGroupState? state, CustomResourceOptions? opts = null)
    public static InstanceGroup get(String name, Output<String> id, InstanceGroupState state, CustomResourceOptions options)
    resources:  _:    type: scaleway:autoscaling:InstanceGroup    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Capacities List<Pulumiverse.Scaleway.Autoscaling.Inputs.InstanceGroupCapacity>
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    CreatedAt string
    Date and time of Instance group's creation (RFC 3339 format).
    DeleteServersOnDestroy bool
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    LoadBalancers List<Pulumiverse.Scaleway.Autoscaling.Inputs.InstanceGroupLoadBalancer>
    The specification of the Load Balancer to link to the Instance group.
    Name string
    The Instance group name.
    ProjectId string
    project_id) The ID of the Project the Instance group is associated with.
    Tags List<string>
    The tags associated with the Instance group.
    TemplateId string
    The ID of the Instance template to attach to the Instance group.
    UpdatedAt string
    Date and time of Instance group's last update (RFC 3339 format).
    Zone string
    zone) The zone in which the Instance group exists.
    Capacities []InstanceGroupCapacityArgs
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    CreatedAt string
    Date and time of Instance group's creation (RFC 3339 format).
    DeleteServersOnDestroy bool
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    LoadBalancers []InstanceGroupLoadBalancerArgs
    The specification of the Load Balancer to link to the Instance group.
    Name string
    The Instance group name.
    ProjectId string
    project_id) The ID of the Project the Instance group is associated with.
    Tags []string
    The tags associated with the Instance group.
    TemplateId string
    The ID of the Instance template to attach to the Instance group.
    UpdatedAt string
    Date and time of Instance group's last update (RFC 3339 format).
    Zone string
    zone) The zone in which the Instance group exists.
    capacities List<InstanceGroupCapacity>
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    createdAt String
    Date and time of Instance group's creation (RFC 3339 format).
    deleteServersOnDestroy Boolean
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    loadBalancers List<InstanceGroupLoadBalancer>
    The specification of the Load Balancer to link to the Instance group.
    name String
    The Instance group name.
    projectId String
    project_id) The ID of the Project the Instance group is associated with.
    tags List<String>
    The tags associated with the Instance group.
    templateId String
    The ID of the Instance template to attach to the Instance group.
    updatedAt String
    Date and time of Instance group's last update (RFC 3339 format).
    zone String
    zone) The zone in which the Instance group exists.
    capacities InstanceGroupCapacity[]
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    createdAt string
    Date and time of Instance group's creation (RFC 3339 format).
    deleteServersOnDestroy boolean
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    loadBalancers InstanceGroupLoadBalancer[]
    The specification of the Load Balancer to link to the Instance group.
    name string
    The Instance group name.
    projectId string
    project_id) The ID of the Project the Instance group is associated with.
    tags string[]
    The tags associated with the Instance group.
    templateId string
    The ID of the Instance template to attach to the Instance group.
    updatedAt string
    Date and time of Instance group's last update (RFC 3339 format).
    zone string
    zone) The zone in which the Instance group exists.
    capacities Sequence[InstanceGroupCapacityArgs]
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    created_at str
    Date and time of Instance group's creation (RFC 3339 format).
    delete_servers_on_destroy bool
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    load_balancers Sequence[InstanceGroupLoadBalancerArgs]
    The specification of the Load Balancer to link to the Instance group.
    name str
    The Instance group name.
    project_id str
    project_id) The ID of the Project the Instance group is associated with.
    tags Sequence[str]
    The tags associated with the Instance group.
    template_id str
    The ID of the Instance template to attach to the Instance group.
    updated_at str
    Date and time of Instance group's last update (RFC 3339 format).
    zone str
    zone) The zone in which the Instance group exists.
    capacities List<Property Map>
    The specification of the minimum and maximum replicas for the Instance group, and the cooldown interval between two scaling events.
    createdAt String
    Date and time of Instance group's creation (RFC 3339 format).
    deleteServersOnDestroy Boolean
    Whether to delete all instances in this group when the group is destroyed. Set to true to tear them down, false (the default) leaves them running.
    loadBalancers List<Property Map>
    The specification of the Load Balancer to link to the Instance group.
    name String
    The Instance group name.
    projectId String
    project_id) The ID of the Project the Instance group is associated with.
    tags List<String>
    The tags associated with the Instance group.
    templateId String
    The ID of the Instance template to attach to the Instance group.
    updatedAt String
    Date and time of Instance group's last update (RFC 3339 format).
    zone String
    zone) The zone in which the Instance group exists.

    Supporting Types

    InstanceGroupCapacity, InstanceGroupCapacityArgs

    CooldownDelay int
    Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
    MaxReplicas int
    The maximum count of Instances for the Instance group.
    MinReplicas int
    The minimum count of Instances for the Instance group.
    CooldownDelay int
    Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
    MaxReplicas int
    The maximum count of Instances for the Instance group.
    MinReplicas int
    The minimum count of Instances for the Instance group.
    cooldownDelay Integer
    Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
    maxReplicas Integer
    The maximum count of Instances for the Instance group.
    minReplicas Integer
    The minimum count of Instances for the Instance group.
    cooldownDelay number
    Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
    maxReplicas number
    The maximum count of Instances for the Instance group.
    minReplicas number
    The minimum count of Instances for the Instance group.
    cooldown_delay int
    Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
    max_replicas int
    The maximum count of Instances for the Instance group.
    min_replicas int
    The minimum count of Instances for the Instance group.
    cooldownDelay Number
    Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
    maxReplicas Number
    The maximum count of Instances for the Instance group.
    minReplicas Number
    The minimum count of Instances for the Instance group.

    InstanceGroupLoadBalancer, InstanceGroupLoadBalancerArgs

    BackendIds List<string>
    The Load Balancer backend IDs.
    Id string
    The ID of the Load Balancer.
    PrivateNetworkId string
    The ID of the Private Network attached to the Load Balancer.
    BackendIds []string
    The Load Balancer backend IDs.
    Id string
    The ID of the Load Balancer.
    PrivateNetworkId string
    The ID of the Private Network attached to the Load Balancer.
    backendIds List<String>
    The Load Balancer backend IDs.
    id String
    The ID of the Load Balancer.
    privateNetworkId String
    The ID of the Private Network attached to the Load Balancer.
    backendIds string[]
    The Load Balancer backend IDs.
    id string
    The ID of the Load Balancer.
    privateNetworkId string
    The ID of the Private Network attached to the Load Balancer.
    backend_ids Sequence[str]
    The Load Balancer backend IDs.
    id str
    The ID of the Load Balancer.
    private_network_id str
    The ID of the Private Network attached to the Load Balancer.
    backendIds List<String>
    The Load Balancer backend IDs.
    id String
    The ID of the Load Balancer.
    privateNetworkId String
    The ID of the Private Network attached to the Load Balancer.

    Import

    Autoscaling Instance groups can be imported using {zone}/{id}, e.g.

    bash

    $ pulumi import scaleway:autoscaling/instanceGroup:InstanceGroup main fr-par-1/11111111-1111-1111-1111-111111111111

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

    Package Details

    Repository
    scaleway pulumiverse/pulumi-scaleway
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the scaleway Terraform Provider.
    scaleway logo
    Scaleway v1.32.0 published on Friday, Aug 1, 2025 by pulumiverse
    pulumiverse/pulumi-scaleway