pulumi-gcp-kotlin/com.pulumi.gcp.compute.kotlin/InstanceGroupArgs

InstanceGroupArgs

data class InstanceGroupArgs(val description: Output<String>? = null, val instances: Output<List<String>>? = null, val name: Output<String>? = null, val namedPorts: Output<List<InstanceGroupNamedPortArgs>>? = null, val network: Output<String>? = null, val project: Output<String>? = null, val zone: Output<String>? = null) : ConvertibleToJava<InstanceGroupArgs>

Creates a group of dissimilar Compute Engine virtual machine instances. For more information, see the official documentation and API

Example Usage

Empty Instance Group

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const test = new gcp.compute.InstanceGroup("test", {
    name: "test",
    description: "Test instance group",
    zone: "us-central1-a",
    network: _default.id,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
test = gcp.compute.InstanceGroup("test",
    name="test",
    description="Test instance group",
    zone="us-central1-a",
    network=default["id"])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var test = new Gcp.Compute.InstanceGroup("test", new()
    {
        Name = "test",
        Description = "Test instance group",
        Zone = "us-central1-a",
        Network = @default.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewInstanceGroup(ctx, "test", &compute.InstanceGroupArgs{
			Name:        pulumi.String("test"),
			Description: pulumi.String("Test instance group"),
			Zone:        pulumi.String("us-central1-a"),
			Network:     pulumi.Any(_default.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.InstanceGroup;
import com.pulumi.gcp.compute.InstanceGroupArgs;
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 test = new InstanceGroup("test", InstanceGroupArgs.builder()
            .name("test")
            .description("Test instance group")
            .zone("us-central1-a")
            .network(default_.id())
            .build());
    }
}
Content copied to clipboard
resources:
  test:
    type: gcp:compute:InstanceGroup
    properties:
      name: test
      description: Test instance group
      zone: us-central1-a
      network: ${default.id}
Content copied to clipboard

Example Usage - With instances and named ports

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const webservers = new gcp.compute.InstanceGroup("webservers", {
    name: "webservers",
    description: "Test instance group",
    instances: [
        test.id,
        test2.id,
    ],
    namedPorts: [
        {
            name: "http",
            port: 8080,
        },
        {
            name: "https",
            port: 8443,
        },
    ],
    zone: "us-central1-a",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
webservers = gcp.compute.InstanceGroup("webservers",
    name="webservers",
    description="Test instance group",
    instances=[
        test["id"],
        test2["id"],
    ],
    named_ports=[
        {
            "name": "http",
            "port": 8080,
        },
        {
            "name": "https",
            "port": 8443,
        },
    ],
    zone="us-central1-a")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var webservers = new Gcp.Compute.InstanceGroup("webservers", new()
    {
        Name = "webservers",
        Description = "Test instance group",
        Instances = new[]
        {
            test.Id,
            test2.Id,
        },
        NamedPorts = new[]
        {
            new Gcp.Compute.Inputs.InstanceGroupNamedPortArgs
            {
                Name = "http",
                Port = 8080,
            },
            new Gcp.Compute.Inputs.InstanceGroupNamedPortArgs
            {
                Name = "https",
                Port = 8443,
            },
        },
        Zone = "us-central1-a",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewInstanceGroup(ctx, "webservers", &compute.InstanceGroupArgs{
			Name:        pulumi.String("webservers"),
			Description: pulumi.String("Test instance group"),
			Instances: pulumi.StringArray{
				test.Id,
				test2.Id,
			},
			NamedPorts: compute.InstanceGroupNamedPortTypeArray{
				&compute.InstanceGroupNamedPortTypeArgs{
					Name: pulumi.String("http"),
					Port: pulumi.Int(8080),
				},
				&compute.InstanceGroupNamedPortTypeArgs{
					Name: pulumi.String("https"),
					Port: pulumi.Int(8443),
				},
			},
			Zone: pulumi.String("us-central1-a"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.InstanceGroup;
import com.pulumi.gcp.compute.InstanceGroupArgs;
import com.pulumi.gcp.compute.inputs.InstanceGroupNamedPortArgs;
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 webservers = new InstanceGroup("webservers", InstanceGroupArgs.builder()
            .name("webservers")
            .description("Test instance group")
            .instances(
                test.id(),
                test2.id())
            .namedPorts(
                InstanceGroupNamedPortArgs.builder()
                    .name("http")
                    .port("8080")
                    .build(),
                InstanceGroupNamedPortArgs.builder()
                    .name("https")
                    .port("8443")
                    .build())
            .zone("us-central1-a")
            .build());
    }
}
Content copied to clipboard
resources:
  webservers:
    type: gcp:compute:InstanceGroup
    properties:
      name: webservers
      description: Test instance group
      instances:
        - ${test.id}
        - ${test2.id}
      namedPorts:
        - name: http
          port: '8080'
        - name: https
          port: '8443'
      zone: us-central1-a
Content copied to clipboard

Import

Instance groups can be imported using the zone and name with an optional project, e.g.

  • projects/{{project_id}}/zones/{{zone}}/instanceGroups/{{instance_group_id}}

  • {{project_id}}/{{zone}}/{{instance_group_id}}

  • {{zone}}/{{instance_group_id}} When using the pulumi import command, instance groups can be imported using one of the formats above. For example:

$ pulumi import gcp:compute/instanceGroup:InstanceGroup default {{zone}}/{{instance_group_id}}
Content copied to clipboard
$ pulumi import gcp:compute/instanceGroup:InstanceGroup default {{project_id}}/{{zone}}/{{instance_group_id}}
Content copied to clipboard
$ pulumi import gcp:compute/instanceGroup:InstanceGroup default projects/{{project_id}}/zones/{{zone}}/instanceGroups/{{instance_group_id}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(description: Output<String>? = null, instances: Output<List<String>>? = null, name: Output<String>? = null, namedPorts: Output<List<InstanceGroupNamedPortArgs>>? = null, network: Output<String>? = null, project: Output<String>? = null, zone: Output<String>? = null)

Properties

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

An optional textual description of the instance group.

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

The list of instances in the group, in self_link format. When adding instances they must all be in the same network and zone as the instance group.

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

The name of the instance group. Must be 1-63 characters long and comply with RFC1035. Supported characters include lowercase letters, numbers, and hyphens.

Link copied to clipboard
val namedPorts: Output<List<InstanceGroupNamedPortArgs>>? = null

The named port configuration. See the section below for details on configuration. Structure is documented below.

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

The URL of the network the instance group is in. If this is different from the network where the instances are in, the creation fails. Defaults to the network where the instances are in (if neither network nor instances is specified, this field will be blank).

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

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

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

The zone that this instance group should be created in.

Functions

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