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

InstanceGroupMembership

class InstanceGroupMembership : KotlinCustomResource

Represents the Instance membership to the Instance Group.

NOTE You can use this resource instead of the instances field in the gcp.compute.InstanceGroup, however it's not recommended to use it alongside this field. It might cause inconsistencies, as they can end up competing over control. NOTE This resource has been added to avoid a situation, where after Instance is recreated, it's removed from Instance Group and it's needed to perform apply twice. To avoid situations like this, please use this resource with the lifecycle replace_triggered_by method, with the passed Instance's ID. To get more information about InstanceGroupMembership, see:

Example Usage

Instance Group Membership

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const default_network = new gcp.compute.Network("default-network", {name: "network"});
const default_instance = new gcp.compute.Instance("default-instance", {
    name: "instance",
    machineType: "e2-medium",
    bootDisk: {
        initializeParams: {
            image: "debian-cloud/debian-11",
        },
    },
    networkInterfaces: [{
        network: default_network.name,
    }],
});
const default_instance_group = new gcp.compute.InstanceGroup("default-instance-group", {name: "instance-group"});
const default_ig_membership = new gcp.compute.InstanceGroupMembership("default-ig-membership", {
    instance: default_instance.selfLink,
    instanceGroup: default_instance_group.name,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default_network = gcp.compute.Network("default-network", name="network")
default_instance = gcp.compute.Instance("default-instance",
    name="instance",
    machine_type="e2-medium",
    boot_disk={
        "initialize_params": {
            "image": "debian-cloud/debian-11",
        },
    },
    network_interfaces=[{
        "network": default_network.name,
    }])
default_instance_group = gcp.compute.InstanceGroup("default-instance-group", name="instance-group")
default_ig_membership = gcp.compute.InstanceGroupMembership("default-ig-membership",
    instance=default_instance.self_link,
    instance_group=default_instance_group.name)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var default_network = new Gcp.Compute.Network("default-network", new()
    {
        Name = "network",
    });
    var default_instance = new Gcp.Compute.Instance("default-instance", new()
    {
        Name = "instance",
        MachineType = "e2-medium",
        BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
        {
            InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
            {
                Image = "debian-cloud/debian-11",
            },
        },
        NetworkInterfaces = new[]
        {
            new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
            {
                Network = default_network.Name,
            },
        },
    });
    var default_instance_group = new Gcp.Compute.InstanceGroup("default-instance-group", new()
    {
        Name = "instance-group",
    });
    var default_ig_membership = new Gcp.Compute.InstanceGroupMembership("default-ig-membership", new()
    {
        Instance = default_instance.SelfLink,
        InstanceGroup = default_instance_group.Name,
    });
});
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.NewNetwork(ctx, "default-network", &compute.NetworkArgs{
			Name: pulumi.String("network"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewInstance(ctx, "default-instance", &compute.InstanceArgs{
			Name:        pulumi.String("instance"),
			MachineType: pulumi.String("e2-medium"),
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String("debian-cloud/debian-11"),
				},
			},
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					Network: default_network.Name,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewInstanceGroup(ctx, "default-instance-group", &compute.InstanceGroupArgs{
			Name: pulumi.String("instance-group"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewInstanceGroupMembership(ctx, "default-ig-membership", &compute.InstanceGroupMembershipArgs{
			Instance:      default_instance.SelfLink,
			InstanceGroup: default_instance_group.Name,
		})
		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.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Instance;
import com.pulumi.gcp.compute.InstanceArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskInitializeParamsArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.gcp.compute.InstanceGroup;
import com.pulumi.gcp.compute.InstanceGroupArgs;
import com.pulumi.gcp.compute.InstanceGroupMembership;
import com.pulumi.gcp.compute.InstanceGroupMembershipArgs;
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 default_network = new Network("default-network", NetworkArgs.builder()
            .name("network")
            .build());
        var default_instance = new Instance("default-instance", InstanceArgs.builder()
            .name("instance")
            .machineType("e2-medium")
            .bootDisk(InstanceBootDiskArgs.builder()
                .initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
                    .image("debian-cloud/debian-11")
                    .build())
                .build())
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .network(default_network.name())
                .build())
            .build());
        var default_instance_group = new InstanceGroup("default-instance-group", InstanceGroupArgs.builder()
            .name("instance-group")
            .build());
        var default_ig_membership = new InstanceGroupMembership("default-ig-membership", InstanceGroupMembershipArgs.builder()
            .instance(default_instance.selfLink())
            .instanceGroup(default_instance_group.name())
            .build());
    }
}
Content copied to clipboard
resources:
  default-network:
    type: gcp:compute:Network
    properties:
      name: network
  default-instance:
    type: gcp:compute:Instance
    properties:
      name: instance
      machineType: e2-medium
      bootDisk:
        initializeParams:
          image: debian-cloud/debian-11
      networkInterfaces:
        - network: ${["default-network"].name}
  default-instance-group:
    type: gcp:compute:InstanceGroup
    properties:
      name: instance-group
  default-ig-membership:
    type: gcp:compute:InstanceGroupMembership
    properties:
      instance: ${["default-instance"].selfLink}
      instanceGroup: ${["default-instance-group"].name}
Content copied to clipboard

Import

InstanceGroupMembership can be imported using any of these accepted formats:

  • projects/{{project}}/zones/{{zone}}/instanceGroups/{{instance_group}}/{{instance}}

  • {{project}}/{{zone}}/{{instance_group}}/{{instance}}

  • {{zone}}/{{instance_group}}/{{instance}}

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

$ pulumi import gcp:compute/instanceGroupMembership:InstanceGroupMembership default projects/{{project}}/zones/{{zone}}/instanceGroups/{{instance_group}}/{{instance}}
Content copied to clipboard
$ pulumi import gcp:compute/instanceGroupMembership:InstanceGroupMembership default {{project}}/{{zone}}/{{instance_group}}/{{instance}}
Content copied to clipboard
$ pulumi import gcp:compute/instanceGroupMembership:InstanceGroupMembership default {{zone}}/{{instance_group}}/{{instance}}
Content copied to clipboard
$ pulumi import gcp:compute/instanceGroupMembership:InstanceGroupMembership default {{instance_group}}/{{instance}}
Content copied to clipboard

Properties

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val instance: Output<String>

An instance being added to the InstanceGroup

Link copied to clipboard
val instanceGroup: Output<String>

Represents an Instance Group resource name that the instance belongs to.

Link copied to clipboard
val project: Output<String>

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 pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val zone: Output<String>?

A reference to the zone where the instance group resides.