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

Feature

class Feature : KotlinCustomResource

Feature represents the settings and status of any Hub Feature. To get more information about Feature, see:

API documentation
How-to Guides

Registering a Cluster

Example Usage

Gkehub Feature Multi Cluster Ingress

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const cluster = new gcp.container.Cluster("cluster", {
    name: "my-cluster",
    location: "us-central1-a",
    initialNodeCount: 1,
});
const membership = new gcp.gkehub.Membership("membership", {
    membershipId: "my-membership",
    endpoint: {
        gkeCluster: {
            resourceLink: pulumi.interpolate`//container.googleapis.com/${cluster.id}`,
        },
    },
    description: "Membership",
});
const feature = new gcp.gkehub.Feature("feature", {
    name: "multiclusteringress",
    location: "global",
    spec: {
        multiclusteringress: {
            configMembership: membership.id,
        },
    },
});

import pulumi
import pulumi_gcp as gcp
cluster = gcp.container.Cluster("cluster",
    name="my-cluster",
    location="us-central1-a",
    initial_node_count=1)
membership = gcp.gkehub.Membership("membership",
    membership_id="my-membership",
    endpoint={
        "gke_cluster": {
            "resource_link": cluster.id.apply(lambda id: f"//container.googleapis.com/{id}"),
        },
    },
    description="Membership")
feature = gcp.gkehub.Feature("feature",
    name="multiclusteringress",
    location="global",
    spec={
        "multiclusteringress": {
            "config_membership": membership.id,
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var cluster = new Gcp.Container.Cluster("cluster", new()
    {
        Name = "my-cluster",
        Location = "us-central1-a",
        InitialNodeCount = 1,
    });
    var membership = new Gcp.GkeHub.Membership("membership", new()
    {
        MembershipId = "my-membership",
        Endpoint = new Gcp.GkeHub.Inputs.MembershipEndpointArgs
        {
            GkeCluster = new Gcp.GkeHub.Inputs.MembershipEndpointGkeClusterArgs
            {
                ResourceLink = cluster.Id.Apply(id => $"//container.googleapis.com/{id}"),
            },
        },
        Description = "Membership",
    });
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "multiclusteringress",
        Location = "global",
        Spec = new Gcp.GkeHub.Inputs.FeatureSpecArgs
        {
            Multiclusteringress = new Gcp.GkeHub.Inputs.FeatureSpecMulticlusteringressArgs
            {
                ConfigMembership = membership.Id,
            },
        },
    });
});

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 {
		cluster, err := container.NewCluster(ctx, "cluster", &container.ClusterArgs{
			Name:             pulumi.String("my-cluster"),
			Location:         pulumi.String("us-central1-a"),
			InitialNodeCount: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		membership, err := gkehub.NewMembership(ctx, "membership", &gkehub.MembershipArgs{
			MembershipId: pulumi.String("my-membership"),
			Endpoint: &gkehub.MembershipEndpointArgs{
				GkeCluster: &gkehub.MembershipEndpointGkeClusterArgs{
					ResourceLink: cluster.ID().ApplyT(func(id string) (string, error) {
						return fmt.Sprintf("//container.googleapis.com/%v", id), nil
					}).(pulumi.StringOutput),
				},
			},
			Description: pulumi.String("Membership"),
		})
		if err != nil {
			return err
		}
		_, err = gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("multiclusteringress"),
			Location: pulumi.String("global"),
			Spec: &gkehub.FeatureSpecArgs{
				Multiclusteringress: &gkehub.FeatureSpecMulticlusteringressArgs{
					ConfigMembership: membership.ID(),
				},
			},
		})
		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.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.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecMulticlusteringressArgs;
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 cluster = new Cluster("cluster", ClusterArgs.builder()
            .name("my-cluster")
            .location("us-central1-a")
            .initialNodeCount(1)
            .build());
        var membership = new Membership("membership", MembershipArgs.builder()
            .membershipId("my-membership")
            .endpoint(MembershipEndpointArgs.builder()
                .gkeCluster(MembershipEndpointGkeClusterArgs.builder()
                    .resourceLink(cluster.id().applyValue(id -> String.format("//container.googleapis.com/%s", id)))
                    .build())
                .build())
            .description("Membership")
            .build());
        var feature = new Feature("feature", FeatureArgs.builder()
            .name("multiclusteringress")
            .location("global")
            .spec(FeatureSpecArgs.builder()
                .multiclusteringress(FeatureSpecMulticlusteringressArgs.builder()
                    .configMembership(membership.id())
                    .build())
                .build())
            .build());
    }
}

resources:
  cluster:
    type: gcp:container:Cluster
    properties:
      name: my-cluster
      location: us-central1-a
      initialNodeCount: 1
  membership:
    type: gcp:gkehub:Membership
    properties:
      membershipId: my-membership
      endpoint:
        gkeCluster:
          resourceLink: //container.googleapis.com/${cluster.id}
      description: Membership
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: multiclusteringress
      location: global
      spec:
        multiclusteringress:
          configMembership: ${membership.id}

Gkehub Feature Multi Cluster Service Discovery

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "multiclusterservicediscovery",
    location: "global",
    labels: {
        foo: "bar",
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="multiclusterservicediscovery",
    location="global",
    labels={
        "foo": "bar",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "multiclusterservicediscovery",
        Location = "global",
        Labels =
        {
            { "foo", "bar" },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("multiclusterservicediscovery"),
			Location: pulumi.String("global"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("multiclusterservicediscovery")
            .location("global")
            .labels(Map.of("foo", "bar"))
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: multiclusterservicediscovery
      location: global
      labels:
        foo: bar

Gkehub Feature Anthos Service Mesh

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "servicemesh",
    location: "global",
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="servicemesh",
    location="global")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "servicemesh",
        Location = "global",
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("servicemesh"),
			Location: pulumi.String("global"),
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("servicemesh")
            .location("global")
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: servicemesh
      location: global

Enable Fleet Observability For Default Logs With Copy

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "fleetobservability",
    location: "global",
    spec: {
        fleetobservability: {
            loggingConfig: {
                defaultConfig: {
                    mode: "COPY",
                },
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="fleetobservability",
    location="global",
    spec={
        "fleetobservability": {
            "logging_config": {
                "default_config": {
                    "mode": "COPY",
                },
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "fleetobservability",
        Location = "global",
        Spec = new Gcp.GkeHub.Inputs.FeatureSpecArgs
        {
            Fleetobservability = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityArgs
            {
                LoggingConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigArgs
                {
                    DefaultConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs
                    {
                        Mode = "COPY",
                    },
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("fleetobservability"),
			Location: pulumi.String("global"),
			Spec: &gkehub.FeatureSpecArgs{
				Fleetobservability: &gkehub.FeatureSpecFleetobservabilityArgs{
					LoggingConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigArgs{
						DefaultConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs{
							Mode: pulumi.String("COPY"),
						},
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("fleetobservability")
            .location("global")
            .spec(FeatureSpecArgs.builder()
                .fleetobservability(FeatureSpecFleetobservabilityArgs.builder()
                    .loggingConfig(FeatureSpecFleetobservabilityLoggingConfigArgs.builder()
                        .defaultConfig(FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs.builder()
                            .mode("COPY")
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: fleetobservability
      location: global
      spec:
        fleetobservability:
          loggingConfig:
            defaultConfig:
              mode: COPY

Enable Fleet Observability For Scope Logs With Move

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "fleetobservability",
    location: "global",
    spec: {
        fleetobservability: {
            loggingConfig: {
                fleetScopeLogsConfig: {
                    mode: "MOVE",
                },
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="fleetobservability",
    location="global",
    spec={
        "fleetobservability": {
            "logging_config": {
                "fleet_scope_logs_config": {
                    "mode": "MOVE",
                },
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "fleetobservability",
        Location = "global",
        Spec = new Gcp.GkeHub.Inputs.FeatureSpecArgs
        {
            Fleetobservability = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityArgs
            {
                LoggingConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigArgs
                {
                    FleetScopeLogsConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs
                    {
                        Mode = "MOVE",
                    },
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("fleetobservability"),
			Location: pulumi.String("global"),
			Spec: &gkehub.FeatureSpecArgs{
				Fleetobservability: &gkehub.FeatureSpecFleetobservabilityArgs{
					LoggingConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigArgs{
						FleetScopeLogsConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs{
							Mode: pulumi.String("MOVE"),
						},
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("fleetobservability")
            .location("global")
            .spec(FeatureSpecArgs.builder()
                .fleetobservability(FeatureSpecFleetobservabilityArgs.builder()
                    .loggingConfig(FeatureSpecFleetobservabilityLoggingConfigArgs.builder()
                        .fleetScopeLogsConfig(FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs.builder()
                            .mode("MOVE")
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: fleetobservability
      location: global
      spec:
        fleetobservability:
          loggingConfig:
            fleetScopeLogsConfig:
              mode: MOVE

Enable Fleet Observability For Both Default And Scope Logs

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "fleetobservability",
    location: "global",
    spec: {
        fleetobservability: {
            loggingConfig: {
                defaultConfig: {
                    mode: "COPY",
                },
                fleetScopeLogsConfig: {
                    mode: "MOVE",
                },
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="fleetobservability",
    location="global",
    spec={
        "fleetobservability": {
            "logging_config": {
                "default_config": {
                    "mode": "COPY",
                },
                "fleet_scope_logs_config": {
                    "mode": "MOVE",
                },
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "fleetobservability",
        Location = "global",
        Spec = new Gcp.GkeHub.Inputs.FeatureSpecArgs
        {
            Fleetobservability = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityArgs
            {
                LoggingConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigArgs
                {
                    DefaultConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs
                    {
                        Mode = "COPY",
                    },
                    FleetScopeLogsConfig = new Gcp.GkeHub.Inputs.FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs
                    {
                        Mode = "MOVE",
                    },
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("fleetobservability"),
			Location: pulumi.String("global"),
			Spec: &gkehub.FeatureSpecArgs{
				Fleetobservability: &gkehub.FeatureSpecFleetobservabilityArgs{
					LoggingConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigArgs{
						DefaultConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs{
							Mode: pulumi.String("COPY"),
						},
						FleetScopeLogsConfig: &gkehub.FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs{
							Mode: pulumi.String("MOVE"),
						},
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("fleetobservability")
            .location("global")
            .spec(FeatureSpecArgs.builder()
                .fleetobservability(FeatureSpecFleetobservabilityArgs.builder()
                    .loggingConfig(FeatureSpecFleetobservabilityLoggingConfigArgs.builder()
                        .defaultConfig(FeatureSpecFleetobservabilityLoggingConfigDefaultConfigArgs.builder()
                            .mode("COPY")
                            .build())
                        .fleetScopeLogsConfig(FeatureSpecFleetobservabilityLoggingConfigFleetScopeLogsConfigArgs.builder()
                            .mode("MOVE")
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: fleetobservability
      location: global
      spec:
        fleetobservability:
          loggingConfig:
            defaultConfig:
              mode: COPY
            fleetScopeLogsConfig:
              mode: MOVE

Enable Fleet Default Member Config Service Mesh

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "servicemesh",
    location: "global",
    fleetDefaultMemberConfig: {
        mesh: {
            management: "MANAGEMENT_AUTOMATIC",
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="servicemesh",
    location="global",
    fleet_default_member_config={
        "mesh": {
            "management": "MANAGEMENT_AUTOMATIC",
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "servicemesh",
        Location = "global",
        FleetDefaultMemberConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigArgs
        {
            Mesh = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigMeshArgs
            {
                Management = "MANAGEMENT_AUTOMATIC",
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("servicemesh"),
			Location: pulumi.String("global"),
			FleetDefaultMemberConfig: &gkehub.FeatureFleetDefaultMemberConfigArgs{
				Mesh: &gkehub.FeatureFleetDefaultMemberConfigMeshArgs{
					Management: pulumi.String("MANAGEMENT_AUTOMATIC"),
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigMeshArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("servicemesh")
            .location("global")
            .fleetDefaultMemberConfig(FeatureFleetDefaultMemberConfigArgs.builder()
                .mesh(FeatureFleetDefaultMemberConfigMeshArgs.builder()
                    .management("MANAGEMENT_AUTOMATIC")
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: servicemesh
      location: global
      fleetDefaultMemberConfig:
        mesh:
          management: MANAGEMENT_AUTOMATIC

Enable Fleet Default Member Config Configmanagement

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "configmanagement",
    location: "global",
    fleetDefaultMemberConfig: {
        configmanagement: {
            configSync: {
                git: {
                    syncRepo: "https://github.com/hashicorp/terraform",
                },
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="configmanagement",
    location="global",
    fleet_default_member_config={
        "configmanagement": {
            "config_sync": {
                "git": {
                    "sync_repo": "https://github.com/hashicorp/terraform",
                },
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "configmanagement",
        Location = "global",
        FleetDefaultMemberConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigArgs
        {
            Configmanagement = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigConfigmanagementArgs
            {
                ConfigSync = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncArgs
                {
                    Git = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncGitArgs
                    {
                        SyncRepo = "https://github.com/hashicorp/terraform",
                    },
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("configmanagement"),
			Location: pulumi.String("global"),
			FleetDefaultMemberConfig: &gkehub.FeatureFleetDefaultMemberConfigArgs{
				Configmanagement: &gkehub.FeatureFleetDefaultMemberConfigConfigmanagementArgs{
					ConfigSync: &gkehub.FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncArgs{
						Git: &gkehub.FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncGitArgs{
							SyncRepo: pulumi.String("https://github.com/hashicorp/terraform"),
						},
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigConfigmanagementArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncGitArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("configmanagement")
            .location("global")
            .fleetDefaultMemberConfig(FeatureFleetDefaultMemberConfigArgs.builder()
                .configmanagement(FeatureFleetDefaultMemberConfigConfigmanagementArgs.builder()
                    .configSync(FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncArgs.builder()
                        .git(FeatureFleetDefaultMemberConfigConfigmanagementConfigSyncGitArgs.builder()
                            .syncRepo("https://github.com/hashicorp/terraform")
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: configmanagement
      location: global
      fleetDefaultMemberConfig:
        configmanagement:
          configSync:
            git:
              syncRepo: https://github.com/hashicorp/terraform

Enable Fleet Default Member Config Policycontroller

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "policycontroller",
    location: "global",
    fleetDefaultMemberConfig: {
        policycontroller: {
            policyControllerHubConfig: {
                installSpec: "INSTALL_SPEC_ENABLED",
                exemptableNamespaces: ["foo"],
                policyContent: {
                    bundles: [{
                        bundle: "policy-essentials-v2022",
                        exemptedNamespaces: [
                            "foo",
                            "bar",
                        ],
                    }],
                    templateLibrary: {
                        installation: "ALL",
                    },
                },
                auditIntervalSeconds: 30,
                referentialRulesEnabled: true,
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="policycontroller",
    location="global",
    fleet_default_member_config={
        "policycontroller": {
            "policy_controller_hub_config": {
                "install_spec": "INSTALL_SPEC_ENABLED",
                "exemptable_namespaces": ["foo"],
                "policy_content": {
                    "bundles": [{
                        "bundle": "policy-essentials-v2022",
                        "exempted_namespaces": [
                            "foo",
                            "bar",
                        ],
                    }],
                    "template_library": {
                        "installation": "ALL",
                    },
                },
                "audit_interval_seconds": 30,
                "referential_rules_enabled": True,
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "policycontroller",
        Location = "global",
        FleetDefaultMemberConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigArgs
        {
            Policycontroller = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerArgs
            {
                PolicyControllerHubConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs
                {
                    InstallSpec = "INSTALL_SPEC_ENABLED",
                    ExemptableNamespaces = new[]
                    {
                        "foo",
                    },
                    PolicyContent = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs
                    {
                        Bundles = new[]
                        {
                            new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs
                            {
                                Bundle = "policy-essentials-v2022",
                                ExemptedNamespaces = new[]
                                {
                                    "foo",
                                    "bar",
                                },
                            },
                        },
                        TemplateLibrary = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs
                        {
                            Installation = "ALL",
                        },
                    },
                    AuditIntervalSeconds = 30,
                    ReferentialRulesEnabled = true,
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("policycontroller"),
			Location: pulumi.String("global"),
			FleetDefaultMemberConfig: &gkehub.FeatureFleetDefaultMemberConfigArgs{
				Policycontroller: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerArgs{
					PolicyControllerHubConfig: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs{
						InstallSpec: pulumi.String("INSTALL_SPEC_ENABLED"),
						ExemptableNamespaces: pulumi.StringArray{
							pulumi.String("foo"),
						},
						PolicyContent: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs{
							Bundles: gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArray{
								&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs{
									Bundle: pulumi.String("policy-essentials-v2022"),
									ExemptedNamespaces: pulumi.StringArray{
										pulumi.String("foo"),
										pulumi.String("bar"),
									},
								},
							},
							TemplateLibrary: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs{
								Installation: pulumi.String("ALL"),
							},
						},
						AuditIntervalSeconds:    pulumi.Int(30),
						ReferentialRulesEnabled: pulumi.Bool(true),
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("policycontroller")
            .location("global")
            .fleetDefaultMemberConfig(FeatureFleetDefaultMemberConfigArgs.builder()
                .policycontroller(FeatureFleetDefaultMemberConfigPolicycontrollerArgs.builder()
                    .policyControllerHubConfig(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs.builder()
                        .installSpec("INSTALL_SPEC_ENABLED")
                        .exemptableNamespaces("foo")
                        .policyContent(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs.builder()
                            .bundles(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs.builder()
                                .bundle("policy-essentials-v2022")
                                .exemptedNamespaces(
                                    "foo",
                                    "bar")
                                .build())
                            .templateLibrary(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs.builder()
                                .installation("ALL")
                                .build())
                            .build())
                        .auditIntervalSeconds(30)
                        .referentialRulesEnabled(true)
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: policycontroller
      location: global
      fleetDefaultMemberConfig:
        policycontroller:
          policyControllerHubConfig:
            installSpec: INSTALL_SPEC_ENABLED
            exemptableNamespaces:
              - foo
            policyContent:
              bundles:
                - bundle: policy-essentials-v2022
                  exemptedNamespaces:
                    - foo
                    - bar
              templateLibrary:
                installation: ALL
            auditIntervalSeconds: 30
            referentialRulesEnabled: true

Enable Fleet Default Member Config Policycontroller Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "policycontroller",
    location: "global",
    fleetDefaultMemberConfig: {
        policycontroller: {
            policyControllerHubConfig: {
                installSpec: "INSTALL_SPEC_SUSPENDED",
                policyContent: {
                    bundles: [
                        {
                            bundle: "pci-dss-v3.2.1",
                            exemptedNamespaces: [
                                "baz",
                                "bar",
                            ],
                        },
                        {
                            bundle: "nist-sp-800-190",
                            exemptedNamespaces: [],
                        },
                    ],
                    templateLibrary: {
                        installation: "ALL",
                    },
                },
                constraintViolationLimit: 50,
                referentialRulesEnabled: true,
                logDeniesEnabled: true,
                mutationEnabled: true,
                deploymentConfigs: [
                    {
                        component: "admission",
                        replicaCount: 2,
                        podAffinity: "ANTI_AFFINITY",
                    },
                    {
                        component: "audit",
                        containerResources: {
                            limits: {
                                memory: "1Gi",
                                cpu: "1.5",
                            },
                            requests: {
                                memory: "500Mi",
                                cpu: "150m",
                            },
                        },
                        podTolerations: [{
                            key: "key1",
                            operator: "Equal",
                            value: "value1",
                            effect: "NoSchedule",
                        }],
                    },
                ],
                monitoring: {
                    backends: ["PROMETHEUS"],
                },
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="policycontroller",
    location="global",
    fleet_default_member_config={
        "policycontroller": {
            "policy_controller_hub_config": {
                "install_spec": "INSTALL_SPEC_SUSPENDED",
                "policy_content": {
                    "bundles": [
                        {
                            "bundle": "pci-dss-v3.2.1",
                            "exempted_namespaces": [
                                "baz",
                                "bar",
                            ],
                        },
                        {
                            "bundle": "nist-sp-800-190",
                            "exempted_namespaces": [],
                        },
                    ],
                    "template_library": {
                        "installation": "ALL",
                    },
                },
                "constraint_violation_limit": 50,
                "referential_rules_enabled": True,
                "log_denies_enabled": True,
                "mutation_enabled": True,
                "deployment_configs": [
                    {
                        "component": "admission",
                        "replica_count": 2,
                        "pod_affinity": "ANTI_AFFINITY",
                    },
                    {
                        "component": "audit",
                        "container_resources": {
                            "limits": {
                                "memory": "1Gi",
                                "cpu": "1.5",
                            },
                            "requests": {
                                "memory": "500Mi",
                                "cpu": "150m",
                            },
                        },
                        "pod_tolerations": [{
                            "key": "key1",
                            "operator": "Equal",
                            "value": "value1",
                            "effect": "NoSchedule",
                        }],
                    },
                ],
                "monitoring": {
                    "backends": ["PROMETHEUS"],
                },
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "policycontroller",
        Location = "global",
        FleetDefaultMemberConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigArgs
        {
            Policycontroller = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerArgs
            {
                PolicyControllerHubConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs
                {
                    InstallSpec = "INSTALL_SPEC_SUSPENDED",
                    PolicyContent = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs
                    {
                        Bundles = new[]
                        {
                            new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs
                            {
                                Bundle = "pci-dss-v3.2.1",
                                ExemptedNamespaces = new[]
                                {
                                    "baz",
                                    "bar",
                                },
                            },
                            new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs
                            {
                                Bundle = "nist-sp-800-190",
                                ExemptedNamespaces = new() { },
                            },
                        },
                        TemplateLibrary = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs
                        {
                            Installation = "ALL",
                        },
                    },
                    ConstraintViolationLimit = 50,
                    ReferentialRulesEnabled = true,
                    LogDeniesEnabled = true,
                    MutationEnabled = true,
                    DeploymentConfigs = new[]
                    {
                        new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs
                        {
                            Component = "admission",
                            ReplicaCount = 2,
                            PodAffinity = "ANTI_AFFINITY",
                        },
                        new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs
                        {
                            Component = "audit",
                            ContainerResources = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesArgs
                            {
                                Limits = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesLimitsArgs
                                {
                                    Memory = "1Gi",
                                    Cpu = "1.5",
                                },
                                Requests = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesRequestsArgs
                                {
                                    Memory = "500Mi",
                                    Cpu = "150m",
                                },
                            },
                            PodTolerations = new[]
                            {
                                new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigPodTolerationArgs
                                {
                                    Key = "key1",
                                    Operator = "Equal",
                                    Value = "value1",
                                    Effect = "NoSchedule",
                                },
                            },
                        },
                    },
                    Monitoring = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigMonitoringArgs
                    {
                        Backends = new[]
                        {
                            "PROMETHEUS",
                        },
                    },
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("policycontroller"),
			Location: pulumi.String("global"),
			FleetDefaultMemberConfig: &gkehub.FeatureFleetDefaultMemberConfigArgs{
				Policycontroller: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerArgs{
					PolicyControllerHubConfig: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs{
						InstallSpec: pulumi.String("INSTALL_SPEC_SUSPENDED"),
						PolicyContent: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs{
							Bundles: gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArray{
								&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs{
									Bundle: pulumi.String("pci-dss-v3.2.1"),
									ExemptedNamespaces: pulumi.StringArray{
										pulumi.String("baz"),
										pulumi.String("bar"),
									},
								},
								&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs{
									Bundle:             pulumi.String("nist-sp-800-190"),
									ExemptedNamespaces: pulumi.StringArray{},
								},
							},
							TemplateLibrary: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs{
								Installation: pulumi.String("ALL"),
							},
						},
						ConstraintViolationLimit: pulumi.Int(50),
						ReferentialRulesEnabled:  pulumi.Bool(true),
						LogDeniesEnabled:         pulumi.Bool(true),
						MutationEnabled:          pulumi.Bool(true),
						DeploymentConfigs: gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArray{
							&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs{
								Component:    pulumi.String("admission"),
								ReplicaCount: pulumi.Int(2),
								PodAffinity:  pulumi.String("ANTI_AFFINITY"),
							},
							&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs{
								Component: pulumi.String("audit"),
								ContainerResources: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesArgs{
									Limits: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesLimitsArgs{
										Memory: pulumi.String("1Gi"),
										Cpu:    pulumi.String("1.5"),
									},
									Requests: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesRequestsArgs{
										Memory: pulumi.String("500Mi"),
										Cpu:    pulumi.String("150m"),
									},
								},
								PodTolerations: gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigPodTolerationArray{
									&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigPodTolerationArgs{
										Key:      pulumi.String("key1"),
										Operator: pulumi.String("Equal"),
										Value:    pulumi.String("value1"),
										Effect:   pulumi.String("NoSchedule"),
									},
								},
							},
						},
						Monitoring: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigMonitoringArgs{
							Backends: pulumi.StringArray{
								pulumi.String("PROMETHEUS"),
							},
						},
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigMonitoringArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("policycontroller")
            .location("global")
            .fleetDefaultMemberConfig(FeatureFleetDefaultMemberConfigArgs.builder()
                .policycontroller(FeatureFleetDefaultMemberConfigPolicycontrollerArgs.builder()
                    .policyControllerHubConfig(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs.builder()
                        .installSpec("INSTALL_SPEC_SUSPENDED")
                        .policyContent(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs.builder()
                            .bundles(
                                FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs.builder()
                                    .bundle("pci-dss-v3.2.1")
                                    .exemptedNamespaces(
                                        "baz",
                                        "bar")
                                    .build(),
                                FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentBundleArgs.builder()
                                    .bundle("nist-sp-800-190")
                                    .exemptedNamespaces()
                                    .build())
                            .templateLibrary(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentTemplateLibraryArgs.builder()
                                .installation("ALL")
                                .build())
                            .build())
                        .constraintViolationLimit(50)
                        .referentialRulesEnabled(true)
                        .logDeniesEnabled(true)
                        .mutationEnabled(true)
                        .deploymentConfigs(
                            FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs.builder()
                                .component("admission")
                                .replicaCount(2)
                                .podAffinity("ANTI_AFFINITY")
                                .build(),
                            FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs.builder()
                                .component("audit")
                                .containerResources(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesArgs.builder()
                                    .limits(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesLimitsArgs.builder()
                                        .memory("1Gi")
                                        .cpu("1.5")
                                        .build())
                                    .requests(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigContainerResourcesRequestsArgs.builder()
                                        .memory("500Mi")
                                        .cpu("150m")
                                        .build())
                                    .build())
                                .podTolerations(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigPodTolerationArgs.builder()
                                    .key("key1")
                                    .operator("Equal")
                                    .value("value1")
                                    .effect("NoSchedule")
                                    .build())
                                .build())
                        .monitoring(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigMonitoringArgs.builder()
                            .backends("PROMETHEUS")
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: policycontroller
      location: global
      fleetDefaultMemberConfig:
        policycontroller:
          policyControllerHubConfig:
            installSpec: INSTALL_SPEC_SUSPENDED
            policyContent:
              bundles:
                - bundle: pci-dss-v3.2.1
                  exemptedNamespaces:
                    - baz
                    - bar
                - bundle: nist-sp-800-190
                  exemptedNamespaces: []
              templateLibrary:
                installation: ALL
            constraintViolationLimit: 50
            referentialRulesEnabled: true
            logDeniesEnabled: true
            mutationEnabled: true
            deploymentConfigs:
              - component: admission
                replicaCount: 2
                podAffinity: ANTI_AFFINITY
              - component: audit
                containerResources:
                  limits:
                    memory: 1Gi
                    cpu: '1.5'
                  requests:
                    memory: 500Mi
                    cpu: 150m
                podTolerations:
                  - key: key1
                    operator: Equal
                    value: value1
                    effect: NoSchedule
            monitoring:
              backends:
                - PROMETHEUS

Enable Fleet Default Member Config Policycontroller Minimal

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "policycontroller",
    location: "global",
    fleetDefaultMemberConfig: {
        policycontroller: {
            policyControllerHubConfig: {
                installSpec: "INSTALL_SPEC_ENABLED",
                policyContent: {},
                constraintViolationLimit: 50,
                referentialRulesEnabled: true,
                logDeniesEnabled: true,
                mutationEnabled: true,
                deploymentConfigs: [{
                    component: "admission",
                }],
                monitoring: {},
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="policycontroller",
    location="global",
    fleet_default_member_config={
        "policycontroller": {
            "policy_controller_hub_config": {
                "install_spec": "INSTALL_SPEC_ENABLED",
                "policy_content": {},
                "constraint_violation_limit": 50,
                "referential_rules_enabled": True,
                "log_denies_enabled": True,
                "mutation_enabled": True,
                "deployment_configs": [{
                    "component": "admission",
                }],
                "monitoring": {},
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "policycontroller",
        Location = "global",
        FleetDefaultMemberConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigArgs
        {
            Policycontroller = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerArgs
            {
                PolicyControllerHubConfig = new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs
                {
                    InstallSpec = "INSTALL_SPEC_ENABLED",
                    PolicyContent = null,
                    ConstraintViolationLimit = 50,
                    ReferentialRulesEnabled = true,
                    LogDeniesEnabled = true,
                    MutationEnabled = true,
                    DeploymentConfigs = new[]
                    {
                        new Gcp.GkeHub.Inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs
                        {
                            Component = "admission",
                        },
                    },
                    Monitoring = null,
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("policycontroller"),
			Location: pulumi.String("global"),
			FleetDefaultMemberConfig: &gkehub.FeatureFleetDefaultMemberConfigArgs{
				Policycontroller: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerArgs{
					PolicyControllerHubConfig: &gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs{
						InstallSpec:              pulumi.String("INSTALL_SPEC_ENABLED"),
						PolicyContent:            nil,
						ConstraintViolationLimit: pulumi.Int(50),
						ReferentialRulesEnabled:  pulumi.Bool(true),
						LogDeniesEnabled:         pulumi.Bool(true),
						MutationEnabled:          pulumi.Bool(true),
						DeploymentConfigs: gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArray{
							&gkehub.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs{
								Component: pulumi.String("admission"),
							},
						},
						Monitoring: nil,
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigPolicyContentArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigMonitoringArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("policycontroller")
            .location("global")
            .fleetDefaultMemberConfig(FeatureFleetDefaultMemberConfigArgs.builder()
                .policycontroller(FeatureFleetDefaultMemberConfigPolicycontrollerArgs.builder()
                    .policyControllerHubConfig(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigArgs.builder()
                        .installSpec("INSTALL_SPEC_ENABLED")
                        .policyContent()
                        .constraintViolationLimit(50)
                        .referentialRulesEnabled(true)
                        .logDeniesEnabled(true)
                        .mutationEnabled(true)
                        .deploymentConfigs(FeatureFleetDefaultMemberConfigPolicycontrollerPolicyControllerHubConfigDeploymentConfigArgs.builder()
                            .component("admission")
                            .build())
                        .monitoring()
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: policycontroller
      location: global
      fleetDefaultMemberConfig:
        policycontroller:
          policyControllerHubConfig:
            installSpec: INSTALL_SPEC_ENABLED
            policyContent: {}
            constraintViolationLimit: 50
            referentialRulesEnabled: true
            logDeniesEnabled: true
            mutationEnabled: true
            deploymentConfigs:
              - component: admission
            monitoring: {}

Gkehub Feature Clusterupgrade

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const feature = new gcp.gkehub.Feature("feature", {
    name: "clusterupgrade",
    location: "global",
    spec: {
        clusterupgrade: {
            upstreamFleets: [],
            postConditions: {
                soaking: "60s",
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp
feature = gcp.gkehub.Feature("feature",
    name="clusterupgrade",
    location="global",
    spec={
        "clusterupgrade": {
            "upstream_fleets": [],
            "post_conditions": {
                "soaking": "60s",
            },
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var feature = new Gcp.GkeHub.Feature("feature", new()
    {
        Name = "clusterupgrade",
        Location = "global",
        Spec = new Gcp.GkeHub.Inputs.FeatureSpecArgs
        {
            Clusterupgrade = new Gcp.GkeHub.Inputs.FeatureSpecClusterupgradeArgs
            {
                UpstreamFleets = new() { },
                PostConditions = new Gcp.GkeHub.Inputs.FeatureSpecClusterupgradePostConditionsArgs
                {
                    Soaking = "60s",
                },
            },
        },
    });
});

package main
import (
	"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 {
		_, err := gkehub.NewFeature(ctx, "feature", &gkehub.FeatureArgs{
			Name:     pulumi.String("clusterupgrade"),
			Location: pulumi.String("global"),
			Spec: &gkehub.FeatureSpecArgs{
				Clusterupgrade: &gkehub.FeatureSpecClusterupgradeArgs{
					UpstreamFleets: pulumi.StringArray{},
					PostConditions: &gkehub.FeatureSpecClusterupgradePostConditionsArgs{
						Soaking: pulumi.String("60s"),
					},
				},
			},
		})
		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.gcp.gkehub.Feature;
import com.pulumi.gcp.gkehub.FeatureArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecClusterupgradeArgs;
import com.pulumi.gcp.gkehub.inputs.FeatureSpecClusterupgradePostConditionsArgs;
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 feature = new Feature("feature", FeatureArgs.builder()
            .name("clusterupgrade")
            .location("global")
            .spec(FeatureSpecArgs.builder()
                .clusterupgrade(FeatureSpecClusterupgradeArgs.builder()
                    .upstreamFleets()
                    .postConditions(FeatureSpecClusterupgradePostConditionsArgs.builder()
                        .soaking("60s")
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  feature:
    type: gcp:gkehub:Feature
    properties:
      name: clusterupgrade
      location: global
      spec:
        clusterupgrade:
          upstreamFleets: []
          postConditions:
            soaking: 60s

Import

Feature can be imported using any of these accepted formats:

projects/{{project}}/locations/{{location}}/features/{{name}}
{{project}}/{{location}}/{{name}}
{{location}}/{{name}} When using the pulumi import command, Feature can be imported using one of the formats above. For example:

$ pulumi import gcp:gkehub/feature:Feature default projects/{{project}}/locations/{{location}}/features/{{name}}

$ pulumi import gcp:gkehub/feature:Feature default {{project}}/{{location}}/{{name}}

$ pulumi import gcp:gkehub/feature:Feature default {{location}}/{{name}}

Properties

createTime

val createTime: Output<String>

Output only. When the Feature resource was created.

deleteTime

val deleteTime: Output<String>

Output only. When the Feature resource was deleted.

effectiveLabels

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.

fleetDefaultMemberConfig

val fleetDefaultMemberConfig: Output<FeatureFleetDefaultMemberConfig>?

Optional. Fleet Default Membership Configuration. Structure is documented below.

val id: Output<String>

labels

val labels: Output<Map<String, String>>?

GCP labels for this Feature. 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.

location

val location: Output<String>

The location for the resource

name

val name: Output<String>

The full, unique name of this Feature resource

project

val project: Output<String>

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

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiLabels

val pulumiLabels: Output<Map<String, String>>

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

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

resourceStates

val resourceStates: Output<List<FeatureResourceState>>

State of the Feature resource itself. Structure is documented below.

spec

val spec: Output<FeatureSpec>?

Optional. Hub-wide Feature configuration. If this Feature does not support any Hub-wide configuration, this field may be unused. Structure is documented below.

states

val states: Output<List<FeatureState>>

(Output) Output only. The "running state" of the Feature in this Hub. Structure is documented below.

updateTime

val updateTime: Output<String>

(Output) The time this status and any related Feature-specific details were updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z"

urn

val urn: Output<String>