pulumi-gcp-kotlin/com.pulumi.gcp.gkehub.kotlin/MembershipBinding

MembershipBinding

class MembershipBinding : KotlinCustomResource

MembershipBinding is a subresource of a Membership, representing what Fleet Scopes (or other, future Fleet resources) a Membership is bound to. To get more information about MembershipBinding, see:

Example Usage

Gkehub Membership Binding Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const primary = new gcp.container.Cluster("primary", {
    name: "basic-cluster",
    location: "us-central1-a",
    initialNodeCount: 1,
    deletionProtection: true,
    network: "default",
    subnetwork: "default",
});
const membership = new gcp.gkehub.Membership("membership", {
    membershipId: "tf-test-membership_39249",
    endpoint: {
        gkeCluster: {
            resourceLink: pulumi.interpolate`//container.googleapis.com/${primary.id}`,
        },
    },
}, {
    dependsOn: [primary],
});
const scope = new gcp.gkehub.Scope("scope", {scopeId: "tf-test-scope_74391"});
const membershipBinding = new gcp.gkehub.MembershipBinding("membership_binding", {
    membershipBindingId: "tf-test-membership-binding_16511",
    scope: scope.name,
    membershipId: membership.membershipId,
    location: "global",
    labels: {
        keyb: "valueb",
        keya: "valuea",
        keyc: "valuec",
    },
}, {
    dependsOn: [
        membership,
        scope,
    ],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
primary = gcp.container.Cluster("primary",
    name="basic-cluster",
    location="us-central1-a",
    initial_node_count=1,
    deletion_protection=True,
    network="default",
    subnetwork="default")
membership = gcp.gkehub.Membership("membership",
    membership_id="tf-test-membership_39249",
    endpoint={
        "gke_cluster": {
            "resource_link": primary.id.apply(lambda id: f"//container.googleapis.com/{id}"),
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[primary]))
scope = gcp.gkehub.Scope("scope", scope_id="tf-test-scope_74391")
membership_binding = gcp.gkehub.MembershipBinding("membership_binding",
    membership_binding_id="tf-test-membership-binding_16511",
    scope=scope.name,
    membership_id=membership.membership_id,
    location="global",
    labels={
        "keyb": "valueb",
        "keya": "valuea",
        "keyc": "valuec",
    },
    opts = pulumi.ResourceOptions(depends_on=[
            membership,
            scope,
        ]))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var primary = new Gcp.Container.Cluster("primary", new()
    {
        Name = "basic-cluster",
        Location = "us-central1-a",
        InitialNodeCount = 1,
        DeletionProtection = true,
        Network = "default",
        Subnetwork = "default",
    });
    var membership = new Gcp.GkeHub.Membership("membership", new()
    {
        MembershipId = "tf-test-membership_39249",
        Endpoint = new Gcp.GkeHub.Inputs.MembershipEndpointArgs
        {
            GkeCluster = new Gcp.GkeHub.Inputs.MembershipEndpointGkeClusterArgs
            {
                ResourceLink = primary.Id.Apply(id => $"//container.googleapis.com/{id}"),
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            primary,
        },
    });
    var scope = new Gcp.GkeHub.Scope("scope", new()
    {
        ScopeId = "tf-test-scope_74391",
    });
    var membershipBinding = new Gcp.GkeHub.MembershipBinding("membership_binding", new()
    {
        MembershipBindingId = "tf-test-membership-binding_16511",
        Scope = scope.Name,
        MembershipId = membership.MembershipId,
        Location = "global",
        Labels =
        {
            { "keyb", "valueb" },
            { "keya", "valuea" },
            { "keyc", "valuec" },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            membership,
            scope,
        },
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/gkehub"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		primary, err := container.NewCluster(ctx, "primary", &container.ClusterArgs{
			Name:               pulumi.String("basic-cluster"),
			Location:           pulumi.String("us-central1-a"),
			InitialNodeCount:   pulumi.Int(1),
			DeletionProtection: pulumi.Bool(true),
			Network:            pulumi.String("default"),
			Subnetwork:         pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		membership, err := gkehub.NewMembership(ctx, "membership", &gkehub.MembershipArgs{
			MembershipId: pulumi.String("tf-test-membership_39249"),
			Endpoint: &gkehub.MembershipEndpointArgs{
				GkeCluster: &gkehub.MembershipEndpointGkeClusterArgs{
					ResourceLink: primary.ID().ApplyT(func(id string) (string, error) {
						return fmt.Sprintf("//container.googleapis.com/%v", id), nil
					}).(pulumi.StringOutput),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			primary,
		}))
		if err != nil {
			return err
		}
		scope, err := gkehub.NewScope(ctx, "scope", &gkehub.ScopeArgs{
			ScopeId: pulumi.String("tf-test-scope_74391"),
		})
		if err != nil {
			return err
		}
		_, err = gkehub.NewMembershipBinding(ctx, "membership_binding", &gkehub.MembershipBindingArgs{
			MembershipBindingId: pulumi.String("tf-test-membership-binding_16511"),
			Scope:               scope.Name,
			MembershipId:        membership.MembershipId,
			Location:            pulumi.String("global"),
			Labels: pulumi.StringMap{
				"keyb": pulumi.String("valueb"),
				"keya": pulumi.String("valuea"),
				"keyc": pulumi.String("valuec"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			membership,
			scope,
		}))
		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.container.Cluster;
import com.pulumi.gcp.container.ClusterArgs;
import com.pulumi.gcp.gkehub.Membership;
import com.pulumi.gcp.gkehub.MembershipArgs;
import com.pulumi.gcp.gkehub.inputs.MembershipEndpointArgs;
import com.pulumi.gcp.gkehub.inputs.MembershipEndpointGkeClusterArgs;
import com.pulumi.gcp.gkehub.Scope;
import com.pulumi.gcp.gkehub.ScopeArgs;
import com.pulumi.gcp.gkehub.MembershipBinding;
import com.pulumi.gcp.gkehub.MembershipBindingArgs;
import com.pulumi.resources.CustomResourceOptions;
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 primary = new Cluster("primary", ClusterArgs.builder()
            .name("basic-cluster")
            .location("us-central1-a")
            .initialNodeCount(1)
            .deletionProtection("true")
            .network("default")
            .subnetwork("default")
            .build());
        var membership = new Membership("membership", MembershipArgs.builder()
            .membershipId("tf-test-membership_39249")
            .endpoint(MembershipEndpointArgs.builder()
                .gkeCluster(MembershipEndpointGkeClusterArgs.builder()
                    .resourceLink(primary.id().applyValue(id -> String.format("//container.googleapis.com/%s", id)))
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(primary)
                .build());
        var scope = new Scope("scope", ScopeArgs.builder()
            .scopeId("tf-test-scope_74391")
            .build());
        var membershipBinding = new MembershipBinding("membershipBinding", MembershipBindingArgs.builder()
            .membershipBindingId("tf-test-membership-binding_16511")
            .scope(scope.name())
            .membershipId(membership.membershipId())
            .location("global")
            .labels(Map.ofEntries(
                Map.entry("keyb", "valueb"),
                Map.entry("keya", "valuea"),
                Map.entry("keyc", "valuec")
            ))
            .build(), CustomResourceOptions.builder()
                .dependsOn(
                    membership,
                    scope)
                .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:container:Cluster
    properties:
      name: basic-cluster
      location: us-central1-a
      initialNodeCount: 1
      deletionProtection: 'true'
      network: default
      subnetwork: default
  membership:
    type: gcp:gkehub:Membership
    properties:
      membershipId: tf-test-membership_39249
      endpoint:
        gkeCluster:
          resourceLink: //container.googleapis.com/${primary.id}
    options:
      dependson:
        - ${primary}
  scope:
    type: gcp:gkehub:Scope
    properties:
      scopeId: tf-test-scope_74391
  membershipBinding:
    type: gcp:gkehub:MembershipBinding
    name: membership_binding
    properties:
      membershipBindingId: tf-test-membership-binding_16511
      scope: ${scope.name}
      membershipId: ${membership.membershipId}
      location: global
      labels:
        keyb: valueb
        keya: valuea
        keyc: valuec
    options:
      dependson:
        - ${membership}
        - ${scope}
Content copied to clipboard

Import

MembershipBinding can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/memberships/{{membership_id}}/bindings/{{membership_binding_id}}

  • {{project}}/{{location}}/{{membership_id}}/{{membership_binding_id}}

  • {{location}}/{{membership_id}}/{{membership_binding_id}} When using the pulumi import command, MembershipBinding can be imported using one of the formats above. For example:

$ pulumi import gcp:gkehub/membershipBinding:MembershipBinding default projects/{{project}}/locations/{{location}}/memberships/{{membership_id}}/bindings/{{membership_binding_id}}
Content copied to clipboard
$ pulumi import gcp:gkehub/membershipBinding:MembershipBinding default {{project}}/{{location}}/{{membership_id}}/{{membership_binding_id}}
Content copied to clipboard
$ pulumi import gcp:gkehub/membershipBinding:MembershipBinding default {{location}}/{{membership_id}}/{{membership_binding_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val createTime: Output<String>

Time the MembershipBinding was created in UTC.

Link copied to clipboard
val deleteTime: Output<String>

Time the MembershipBinding was deleted in UTC.

Link copied to clipboard
val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

Labels for this Membership binding. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>

Location of the membership

Link copied to clipboard
val membershipBindingId: Output<String>

The client-provided identifier of the membership binding.

Link copied to clipboard
val membershipId: Output<String>

Id of the membership

Link copied to clipboard
val name: Output<String>

The resource name for the membershipbinding itself

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
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val scope: Output<String>

A Workspace resource name in the format projects/*/locations/*/scopes/*. //*/

Link copied to clipboard
val states: Output<List<MembershipBindingState>>

State of the membership binding resource. Structure is documented below.

Link copied to clipboard
val uid: Output<String>

Google-generated UUID for this resource.

Link copied to clipboard
val updateTime: Output<String>

Time the MembershipBinding was updated in UTC.

Link copied to clipboard
val urn: Output<String>