Cluster class

Manages a Google Kubernetes Engine (GKE) cluster.

To get more information about GKE clusters, see:

> On version 5.0.0+ of the provider, you must explicitly set deletionProtection = false and run pulumi up to write the field to state in order to destroy a cluster.

> All arguments and attributes (including certificate outputs) will be stored in the raw state as plaintext. Read more about sensitive data in state.

Example Usage

With A Separately Managed Node Pool (Recommended)

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const _default = new gcp.serviceaccount.Account("default", {
    accountId: "service-account-id",
    displayName: "Service Account",
});
const primary = new gcp.container.Cluster("primary", {
    name: "my-gke-cluster",
    location: "us-central1",
    removeDefaultNodePool: true,
    initialNodeCount: 1,
});
const primaryPreemptibleNodes = new gcp.container.NodePool("primary_preemptible_nodes", {
    name: "my-node-pool",
    location: "us-central1",
    cluster: primary.name,
    nodeCount: 1,
    nodeConfig: {
        preemptible: true,
        machineType: "e2-medium",
        serviceAccount: _default.email,
        oauthScopes: ["https://www.googleapis.com/auth/cloud-platform"],
    },
});

import pulumi
import pulumi_gcp as gcp

default = gcp.serviceaccount.Account("default",
    account_id="service-account-id",
    display_name="Service Account")
primary = gcp.container.Cluster("primary",
    name="my-gke-cluster",
    location="us-central1",
    remove_default_node_pool=True,
    initial_node_count=1)
primary_preemptible_nodes = gcp.container.NodePool("primary_preemptible_nodes",
    name="my-node-pool",
    location="us-central1",
    cluster=primary.name,
    node_count=1,
    node_config={
        "preemptible": True,
        "machine_type": "e2-medium",
        "service_account": default.email,
        "oauth_scopes": ["https://www.googleapis.com/auth/cloud-platform"],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.ServiceAccount.Account("default", new()
    {
        AccountId = "service-account-id",
        DisplayName = "Service Account",
    });

    var primary = new Gcp.Container.Cluster("primary", new()
    {
        Name = "my-gke-cluster",
        Location = "us-central1",
        RemoveDefaultNodePool = true,
        InitialNodeCount = 1,
    });

    var primaryPreemptibleNodes = new Gcp.Container.NodePool("primary_preemptible_nodes", new()
    {
        Name = "my-node-pool",
        Location = "us-central1",
        Cluster = primary.Name,
        NodeCount = 1,
        NodeConfig = new Gcp.Container.Inputs.NodePoolNodeConfigArgs
        {
            Preemptible = true,
            MachineType = "e2-medium",
            ServiceAccount = @default.Email,
            OauthScopes = new[]
            {
                "https://www.googleapis.com/auth/cloud-platform",
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceaccount"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := serviceaccount.NewAccount(ctx, "default", &serviceaccount.AccountArgs{
			AccountId:   pulumi.String("service-account-id"),
			DisplayName: pulumi.String("Service Account"),
		})
		if err != nil {
			return err
		}
		primary, err := container.NewCluster(ctx, "primary", &container.ClusterArgs{
			Name:                  pulumi.String("my-gke-cluster"),
			Location:              pulumi.String("us-central1"),
			RemoveDefaultNodePool: pulumi.Bool(true),
			InitialNodeCount:      pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = container.NewNodePool(ctx, "primary_preemptible_nodes", &container.NodePoolArgs{
			Name:      pulumi.String("my-node-pool"),
			Location:  pulumi.String("us-central1"),
			Cluster:   primary.Name,
			NodeCount: pulumi.Int(1),
			NodeConfig: &container.NodePoolNodeConfigArgs{
				Preemptible:    pulumi.Bool(true),
				MachineType:    pulumi.String("e2-medium"),
				ServiceAccount: _default.Email,
				OauthScopes: pulumi.StringArray{
					pulumi.String("https://www.googleapis.com/auth/cloud-platform"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_serviceaccount_account" "default" {
  account_id   = "service-account-id"
  display_name = "Service Account"
}
resource "gcp_container_cluster" "primary" {
  name                     = "my-gke-cluster"
  location                 = "us-central1"
  remove_default_node_pool = true
  initial_node_count       = 1
}
resource "gcp_container_nodepool" "primary_preemptible_nodes" {
  name       = "my-node-pool"
  location   = "us-central1"
  cluster    = gcp_container_cluster.primary.name
  node_count = 1
  node_config = {
    preemptible     = true
    machine_type    = "e2-medium"
    service_account = gcp_serviceaccount_account.default.email
    oauth_scopes    = ["https://www.googleapis.com/auth/cloud-platform"]
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.serviceaccount.Account;
import com.pulumi.gcp.serviceaccount.AccountArgs;
import com.pulumi.gcp.container.Cluster;
import com.pulumi.gcp.container.ClusterArgs;
import com.pulumi.gcp.container.NodePool;
import com.pulumi.gcp.container.NodePoolArgs;
import com.pulumi.gcp.container.inputs.NodePoolNodeConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
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_ = new Account("default", AccountArgs.builder()
            .accountId("service-account-id")
            .displayName("Service Account")
            .build());

        var primary = new Cluster("primary", ClusterArgs.builder()
            .name("my-gke-cluster")
            .location("us-central1")
            .removeDefaultNodePool(true)
            .initialNodeCount(1)
            .build());

        var primaryPreemptibleNodes = new NodePool("primaryPreemptibleNodes", NodePoolArgs.builder()
            .name("my-node-pool")
            .location("us-central1")
            .cluster(primary.name())
            .nodeCount(1)
            .nodeConfig(NodePoolNodeConfigArgs.builder()
                .preemptible(true)
                .machineType("e2-medium")
                .serviceAccount(default_.email())
                .oauthScopes("https://www.googleapis.com/auth/cloud-platform")
                .build())
            .build());

    }
}

resources:
  default:
    type: gcp:serviceaccount:Account
    properties:
      accountId: service-account-id
      displayName: Service Account
  primary:
    type: gcp:container:Cluster
    properties:
      name: my-gke-cluster
      location: us-central1
      removeDefaultNodePool: true
      initialNodeCount: 1
  primaryPreemptibleNodes:
    type: gcp:container:NodePool
    name: primary_preemptible_nodes
    properties:
      name: my-node-pool
      location: us-central1
      cluster: ${primary.name}
      nodeCount: 1
      nodeConfig:
        preemptible: true
        machineType: e2-medium
        serviceAccount: ${default.email}
        oauthScopes:
          - https://www.googleapis.com/auth/cloud-platform

> Note: It is recommended that node pools be created and managed as separate resources as in the example above. This allows node pools to be added and removed without recreating the cluster. Node pools defined directly in the gcp.container.Cluster resource cannot be removed without re-creating the cluster.

With The Default Node Pool

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const _default = new gcp.serviceaccount.Account("default", {
    accountId: "service-account-id",
    displayName: "Service Account",
});
const primary = new gcp.container.Cluster("primary", {
    name: "marcellus-wallace",
    location: "us-central1-a",
    initialNodeCount: 3,
    nodeConfig: {
        serviceAccount: _default.email,
        oauthScopes: ["https://www.googleapis.com/auth/cloud-platform"],
        labels: {
            foo: "bar",
        },
        tags: [
            "foo",
            "bar",
        ],
    },
});

import pulumi
import pulumi_gcp as gcp

default = gcp.serviceaccount.Account("default",
    account_id="service-account-id",
    display_name="Service Account")
primary = gcp.container.Cluster("primary",
    name="marcellus-wallace",
    location="us-central1-a",
    initial_node_count=3,
    node_config={
        "service_account": default.email,
        "oauth_scopes": ["https://www.googleapis.com/auth/cloud-platform"],
        "labels": {
            "foo": "bar",
        },
        "tags": [
            "foo",
            "bar",
        ],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.ServiceAccount.Account("default", new()
    {
        AccountId = "service-account-id",
        DisplayName = "Service Account",
    });

    var primary = new Gcp.Container.Cluster("primary", new()
    {
        Name = "marcellus-wallace",
        Location = "us-central1-a",
        InitialNodeCount = 3,
        NodeConfig = new Gcp.Container.Inputs.ClusterNodeConfigArgs
        {
            ServiceAccount = @default.Email,
            OauthScopes = new[]
            {
                "https://www.googleapis.com/auth/cloud-platform",
            },
            Labels =
            {
                { "foo", "bar" },
            },
            Tags = new[]
            {
                "foo",
                "bar",
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceaccount"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := serviceaccount.NewAccount(ctx, "default", &serviceaccount.AccountArgs{
			AccountId:   pulumi.String("service-account-id"),
			DisplayName: pulumi.String("Service Account"),
		})
		if err != nil {
			return err
		}
		_, err = container.NewCluster(ctx, "primary", &container.ClusterArgs{
			Name:             pulumi.String("marcellus-wallace"),
			Location:         pulumi.String("us-central1-a"),
			InitialNodeCount: pulumi.Int(3),
			NodeConfig: &container.ClusterNodeConfigArgs{
				ServiceAccount: _default.Email,
				OauthScopes: pulumi.StringArray{
					pulumi.String("https://www.googleapis.com/auth/cloud-platform"),
				},
				Labels: pulumi.StringMap{
					"foo": pulumi.String("bar"),
				},
				Tags: pulumi.StringArray{
					pulumi.String("foo"),
					pulumi.String("bar"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_serviceaccount_account" "default" {
  account_id   = "service-account-id"
  display_name = "Service Account"
}
resource "gcp_container_cluster" "primary" {
  name               = "marcellus-wallace"
  location           = "us-central1-a"
  initial_node_count = 3
  node_config = {
    service_account = gcp_serviceaccount_account.default.email
    oauth_scopes    = ["https://www.googleapis.com/auth/cloud-platform"]
    labels = {
      "foo" = "bar"
    }
    tags = ["foo", "bar"]
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.serviceaccount.Account;
import com.pulumi.gcp.serviceaccount.AccountArgs;
import com.pulumi.gcp.container.Cluster;
import com.pulumi.gcp.container.ClusterArgs;
import com.pulumi.gcp.container.inputs.ClusterNodeConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
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_ = new Account("default", AccountArgs.builder()
            .accountId("service-account-id")
            .displayName("Service Account")
            .build());

        var primary = new Cluster("primary", ClusterArgs.builder()
            .name("marcellus-wallace")
            .location("us-central1-a")
            .initialNodeCount(3)
            .nodeConfig(ClusterNodeConfigArgs.builder()
                .serviceAccount(default_.email())
                .oauthScopes("https://www.googleapis.com/auth/cloud-platform")
                .labels(Map.of("foo", "bar"))
                .tags(
                    "foo",
                    "bar")
                .build())
            .build());

    }
}

resources:
  default:
    type: gcp:serviceaccount:Account
    properties:
      accountId: service-account-id
      displayName: Service Account
  primary:
    type: gcp:container:Cluster
    properties:
      name: marcellus-wallace
      location: us-central1-a
      initialNodeCount: 3
      nodeConfig:
        serviceAccount: ${default.email}
        oauthScopes:
          - https://www.googleapis.com/auth/cloud-platform
        labels:
          foo: bar
        tags:
          - foo
          - bar

Rollback-Safe (Two-Step) Upgrades

To perform a rollback-safe (two-step) control plane upgrade, you first specify a soak duration in the rollbackSafeUpgrade block when changing the minMasterVersion. This upgrades the master but keeps the control plane emulating the older version.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const primary = new gcp.container.Cluster("primary", {
    name: "my-gke-cluster",
    location: "us-central1",
    initialNodeCount: 1,
    minMasterVersion: "1.32.4-gke.200",
    rollbackSafeUpgrade: {
        controlPlaneSoakDuration: "604800s",
    },
});

import pulumi
import pulumi_gcp as gcp

primary = gcp.container.Cluster("primary",
    name="my-gke-cluster",
    location="us-central1",
    initial_node_count=1,
    min_master_version="1.32.4-gke.200",
    rollback_safe_upgrade={
        "control_plane_soak_duration": "604800s",
    })

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 = "my-gke-cluster",
        Location = "us-central1",
        InitialNodeCount = 1,
        MinMasterVersion = "1.32.4-gke.200",
        RollbackSafeUpgrade = new Gcp.Container.Inputs.ClusterRollbackSafeUpgradeArgs
        {
            ControlPlaneSoakDuration = "604800s",
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/container"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := container.NewCluster(ctx, "primary", &container.ClusterArgs{
			Name:             pulumi.String("my-gke-cluster"),
			Location:         pulumi.String("us-central1"),
			InitialNodeCount: pulumi.Int(1),
			MinMasterVersion: pulumi.String("1.32.4-gke.200"),
			RollbackSafeUpgrade: &container.ClusterRollbackSafeUpgradeArgs{
				ControlPlaneSoakDuration: pulumi.String("604800s"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_container_cluster" "primary" {
  name               = "my-gke-cluster"
  location           = "us-central1"
  initial_node_count = 1
  min_master_version = "1.32.4-gke.200"
  rollback_safe_upgrade = {
    control_plane_soak_duration = "604800s"
  }
}

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.container.inputs.ClusterRollbackSafeUpgradeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("my-gke-cluster")
            .location("us-central1")
            .initialNodeCount(1)
            .minMasterVersion("1.32.4-gke.200")
            .rollbackSafeUpgrade(ClusterRollbackSafeUpgradeArgs.builder()
                .controlPlaneSoakDuration("604800s")
                .build())
            .build());

    }
}

resources:
  primary:
    type: gcp:container:Cluster
    properties:
      name: my-gke-cluster
      location: us-central1
      initialNodeCount: 1
      minMasterVersion: 1.32.4-gke.200
      rollbackSafeUpgrade:
        controlPlaneSoakDuration: 604800s

After the soak period concludes, you can declaratively complete the upgrade by specifying the target desiredEmulatedVersion.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const primary = new gcp.container.Cluster("primary", {
    name: "my-gke-cluster",
    location: "us-central1",
    initialNodeCount: 1,
    minMasterVersion: "1.32.4-gke.200",
    rollbackSafeUpgrade: {
        controlPlaneSoakDuration: "604800s",
    },
    desiredEmulatedVersion: "1.32",
});

import pulumi
import pulumi_gcp as gcp

primary = gcp.container.Cluster("primary",
    name="my-gke-cluster",
    location="us-central1",
    initial_node_count=1,
    min_master_version="1.32.4-gke.200",
    rollback_safe_upgrade={
        "control_plane_soak_duration": "604800s",
    },
    desired_emulated_version="1.32")

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 = "my-gke-cluster",
        Location = "us-central1",
        InitialNodeCount = 1,
        MinMasterVersion = "1.32.4-gke.200",
        RollbackSafeUpgrade = new Gcp.Container.Inputs.ClusterRollbackSafeUpgradeArgs
        {
            ControlPlaneSoakDuration = "604800s",
        },
        DesiredEmulatedVersion = "1.32",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/container"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := container.NewCluster(ctx, "primary", &container.ClusterArgs{
			Name:             pulumi.String("my-gke-cluster"),
			Location:         pulumi.String("us-central1"),
			InitialNodeCount: pulumi.Int(1),
			MinMasterVersion: pulumi.String("1.32.4-gke.200"),
			RollbackSafeUpgrade: &container.ClusterRollbackSafeUpgradeArgs{
				ControlPlaneSoakDuration: pulumi.String("604800s"),
			},
			DesiredEmulatedVersion: pulumi.String("1.32"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_container_cluster" "primary" {
  name               = "my-gke-cluster"
  location           = "us-central1"
  initial_node_count = 1
  min_master_version = "1.32.4-gke.200"
  rollback_safe_upgrade = {
    control_plane_soak_duration = "604800s"
  }
  desired_emulated_version = "1.32"
}

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.container.inputs.ClusterRollbackSafeUpgradeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("my-gke-cluster")
            .location("us-central1")
            .initialNodeCount(1)
            .minMasterVersion("1.32.4-gke.200")
            .rollbackSafeUpgrade(ClusterRollbackSafeUpgradeArgs.builder()
                .controlPlaneSoakDuration("604800s")
                .build())
            .desiredEmulatedVersion("1.32")
            .build());

    }
}

resources:
  primary:
    type: gcp:container:Cluster
    properties:
      name: my-gke-cluster
      location: us-central1
      initialNodeCount: 1
      minMasterVersion: 1.32.4-gke.200
      rollbackSafeUpgrade:
        controlPlaneSoakDuration: 604800s
      desiredEmulatedVersion: '1.32'

> Note: If you omit the controlPlaneSoakDuration field completely, GKE bypasses the two-step feature and performs a standard one-step upgrade. You must specify a duration between 6 hours and 7 days.

Autopilot

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const _default = new gcp.serviceaccount.Account("default", {
    accountId: "service-account-id",
    displayName: "Service Account",
});
const primary = new gcp.container.Cluster("primary", {
    name: "marcellus-wallace",
    location: "us-central1-a",
    enableAutopilot: true,
});

import pulumi
import pulumi_gcp as gcp

default = gcp.serviceaccount.Account("default",
    account_id="service-account-id",
    display_name="Service Account")
primary = gcp.container.Cluster("primary",
    name="marcellus-wallace",
    location="us-central1-a",
    enable_autopilot=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.ServiceAccount.Account("default", new()
    {
        AccountId = "service-account-id",
        DisplayName = "Service Account",
    });

    var primary = new Gcp.Container.Cluster("primary", new()
    {
        Name = "marcellus-wallace",
        Location = "us-central1-a",
        EnableAutopilot = true,
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceaccount"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := serviceaccount.NewAccount(ctx, "default", &serviceaccount.AccountArgs{
			AccountId:   pulumi.String("service-account-id"),
			DisplayName: pulumi.String("Service Account"),
		})
		if err != nil {
			return err
		}
		_, err = container.NewCluster(ctx, "primary", &container.ClusterArgs{
			Name:            pulumi.String("marcellus-wallace"),
			Location:        pulumi.String("us-central1-a"),
			EnableAutopilot: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_serviceaccount_account" "default" {
  account_id   = "service-account-id"
  display_name = "Service Account"
}
resource "gcp_container_cluster" "primary" {
  name             = "marcellus-wallace"
  location         = "us-central1-a"
  enable_autopilot = true
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.serviceaccount.Account;
import com.pulumi.gcp.serviceaccount.AccountArgs;
import com.pulumi.gcp.container.Cluster;
import com.pulumi.gcp.container.ClusterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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_ = new Account("default", AccountArgs.builder()
            .accountId("service-account-id")
            .displayName("Service Account")
            .build());

        var primary = new Cluster("primary", ClusterArgs.builder()
            .name("marcellus-wallace")
            .location("us-central1-a")
            .enableAutopilot(true)
            .build());

    }
}

resources:
  default:
    type: gcp:serviceaccount:Account
    properties:
      accountId: service-account-id
      displayName: Service Account
  primary:
    type: gcp:container:Cluster
    properties:
      name: marcellus-wallace
      location: us-central1-a
      enableAutopilot: true

Import

GKE clusters can be imported using the project , location, and name. If the project is omitted, the default provider value will be used. Examples:

projects/{{project_id}}/locations/{{location}}/clusters/{{cluster_id}}
{{project_id}}/{{location}}/{{cluster_id}}
{{location}}/{{cluster_id}}

When using the pulumi import command, GKE clusters can be imported using one of the formats above. For example:

$ pulumi import gcp:container/cluster:Cluster default projects/{{project_id}}/locations/{{location}}/clusters/{{cluster_id}}

$ pulumi import gcp:container/cluster:Cluster default {{project_id}}/{{location}}/{{cluster_id}}

$ pulumi import gcp:container/cluster:Cluster default {{location}}/{{cluster_id}}

> Note: This resource has several fields that control Terraform-specific behavior and aren't present in the API. If they are set in config and you import a cluster, Terraform may need to perform an update immediately after import. Most of these updates should be no-ops but some may modify your cluster if the imported state differs.

For example, the following fields will show diffs if set in config:

minMasterVersion
removeDefaultNodePool

Constructors

Cluster(String name, {ClusterArgs? args, CustomResourceOptions? options}): Creates a new Cluster. name The Pulumi resource name. args Arguments used to configure this Cluster. The set of arguments for Cluster. options Resource options controlling this resource's behavior.
Cluster.reference(String urn): Creates a typed reference to an existing Cluster resource.

Properties

addonsConfig ↔ Output<ClusterAddonsConfig>: The configuration for addons supported by GKE. Structure is documented below.
latefinal
allowNetAdmin ↔ Output<bool?>: Enable NET_ADMIN for the cluster. Defaults to false. This field should only be enabled for Autopilot clusters (enableAutopilot set to true).
latefinal
anonymousAuthenticationConfig ↔ Output<ClusterAnonymousAuthenticationConfig>: Configuration for anonymous authentication restrictions. Structure is documented below.
latefinal
authenticatorGroupsConfig ↔ Output<ClusterAuthenticatorGroupsConfig>: Configuration for the Google Groups for GKE feature. Structure is documented below.
latefinal
autopilotClusterPolicyConfig ↔ Output<ClusterAutopilotClusterPolicyConfig>: Per-cluster configuration of Autopilot cluster policies in GKE clusters. This field can only be configured in non Autopilot clusters. Structure is documented below.
latefinal
autopilotPrivilegedAdmissions ↔ Output<List<String>>: The customer allowlist Cloud Storage paths for the cluster. These paths are used with the --autopilot-privileged-admission flag to authorize privileged workloads in Autopilot clusters. See the Cluster API's PrivilegedAdmissionConfig documentation for more details.
latefinal
binaryAuthorization ↔ Output<ClusterBinaryAuthorization?>: Configuration options for the Binary Authorization feature. Structure is documented below.
latefinal
childResources → Set<Resource>: finalinherited
clusterAutoscaling ↔ Output<ClusterClusterAutoscaling>: Per-cluster configuration of Node Auto-Provisioning with Cluster Autoscaler to automatically adjust the size of the cluster and create/delete node pools based on the current needs of the cluster's workload. See the guide to using Node Auto-Provisioning for more details. Structure is documented below.
latefinal
clusterIpv4Cidr ↔ Output<String>: The IP address range of the Kubernetes pods in this cluster in CIDR notation (e.g. 10.96.0.0/14). Leave blank to have one automatically chosen or specify a /14 block in 10.0.0.0/8. This field will default a new cluster to routes-based, where ipAllocationPolicy is not defined.
latefinal
clusterTelemetry ↔ Output<ClusterClusterTelemetry>: ) Configuration for ClusterTelemetry feature, Structure is documented below.
latefinal
completionSources ↔ Map<String, IOutputCompletionSource>: latefinalinherited
confidentialNodes ↔ Output<ClusterConfidentialNodes>: Configuration for Confidential Nodes feature. Structure is documented below documented below.
latefinal
controlPlaneEndpointsConfig ↔ Output<ClusterControlPlaneEndpointsConfig>: Configuration for all of the cluster's control plane endpoints. Structure is documented below.
latefinal
costManagementConfig ↔ Output<ClusterCostManagementConfig>: Configuration for the Cost Allocation feature. Structure is documented below.
latefinal
databaseEncryption ↔ Output<ClusterDatabaseEncryption>: Structure is documented below.
latefinal
datapathProvider ↔ Output<String>: The desired datapath provider for this cluster. This is set to LEGACY_DATAPATH by default, which uses the IPTables-based kube-proxy implementation. Set to ADVANCED_DATAPATH to enable Dataplane v2.
latefinal
dataplaneOptimizationMode ↔ Output<String?>: The dataplane optimization mode for the cluster. Possible values: SCALE_OPTIMIZED.
latefinal
defaultMaxPodsPerNode ↔ Output<int>: The default maximum number of pods per node in this cluster. This doesn't work on "routes-based" clusters, clusters that don't have IP Aliasing enabled. See the official documentation for more information.
latefinal
defaultSnatStatus ↔ Output<ClusterDefaultSnatStatus>: GKE SNAT DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster, API doc. Structure is documented below
latefinal
deletionPolicy ↔ Output<String>: (Optional) Whether Terraform will be prevented from destroying the resource. Defaults to "DELETE". When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
latefinal
deletionProtection ↔ Output<bool?>: Whether Terraform will be prevented from destroying the cluster. Deleting this cluster via terraform destroy or pulumi up will only succeed if this field is false in the Terraform state.
latefinal
description ↔ Output<String?>: Description of the cluster.
latefinal
desiredEmulatedVersion ↔ Output<String?>: The desired emulated version for the cluster. Used to complete a rollback-safe upgrade after a soak period. Must be in major.minor format (e.g., "1.31"). To complete the upgrade declaratively, set this field to the target minor version. Removing this field from your configuration will not trigger completion.
latefinal
disableL4LbFirewallReconciliation ↔ Output<bool?>: Disable L4 load balancer VPC firewalls to enable firewall policies.
latefinal
dnsConfig ↔ Output<ClusterDnsConfig?>: Configuration for Using Cloud DNS for GKE. Structure is documented below.
latefinal
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.
latefinal
emulatedVersion ↔ Output<String>: The current emulated Kubernetes version running on the GKE cluster control plane.
latefinal
enableAutopilot ↔ Output<bool?>: Enable Autopilot for this cluster. Defaults to false. Note that when this option is enabled, certain features of Standard GKE are not available. See the official documentation for available features.
latefinal
enableCiliumClusterwideNetworkPolicy ↔ Output<bool?>: Whether CiliumClusterWideNetworkPolicy is enabled on this cluster. Defaults to false.
latefinal
enableFqdnNetworkPolicy ↔ Output<bool?>: Whether FQDN Network Policy is enabled on this cluster. Users who enable this feature for existing Standard clusters must restart the GKE Dataplane V2 anetd DaemonSet after enabling it. See the Enable FQDN Network Policy in an existing cluster for more information.
latefinal
enableIntranodeVisibility ↔ Output<bool>: Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
latefinal
enableK8sBetaApis ↔ Output<ClusterEnableK8sBetaApis?>: Configuration for Kubernetes Beta APIs. Structure is documented below.
latefinal
enableKubernetesAlpha ↔ Output<bool?>: Whether to enable Kubernetes Alpha features for this cluster. Note that when this option is enabled, the cluster cannot be upgraded and will be automatically deleted after 30 days.
latefinal
enableL4IlbSubsetting ↔ Output<bool>: Whether L4ILB Subsetting is enabled for this cluster.
latefinal
enableLegacyAbac ↔ Output<bool?>: Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM. Defaults to false
latefinal
enableMultiNetworking ↔ Output<bool?>: Whether multi-networking is enabled for this cluster.
latefinal
enableShieldedNodes ↔ Output<bool?>: Enable Shielded Nodes features on all nodes in this cluster. Defaults to true.
latefinal
enableTpu ↔ Output<bool>: Whether to enable Cloud TPU resources in this cluster. See the official documentation.
latefinal
endpoint ↔ Output<String>: The IP address of this cluster's Kubernetes master.
latefinal
enterpriseConfig ↔ Output<ClusterEnterpriseConfig>: (DEPRECATED) Configuration for Enterprise edition.(https://cloud.google.com/kubernetes-engine/enterprise/docs/concepts/gke-editions). Structure is documented below. Deprecated as GKE Enterprise features are now available without an Enterprise tier. See https://cloud.google.com/blog/products/containers-kubernetes/gke-gets-new-pricing-and-capabilities-on-10th-birthday for the announcement of this change.
latefinal
fleet ↔ Output<ClusterFleet?>: Fleet configuration for the cluster. Structure is documented below.
latefinal
gatewayApiConfig ↔ Output<ClusterGatewayApiConfig>: Configuration for GKE Gateway API controller. Structure is documented below.
latefinal
gkeAutoUpgradeConfig ↔ Output<ClusterGkeAutoUpgradeConfig>: Configuration options for the auto-upgrade patch type feature, which provide more control over the speed of automatic upgrades of your GKE clusters. Structure is documented below.
latefinal
hashCode → int: The hash code for this object.
no setterinherited
id ↔ Output<String>: getter/setter pairinherited
identityServiceConfig ↔ Output<ClusterIdentityServiceConfig>: . Structure is documented below.
latefinal
ignoreNodeCountChanges ↔ Output<bool?>: Whether to ignore external changes (drift) to the GKE node count (e.g. from GKE autoscaling). Setting this to true skips querying Compute Engine Instance Group Managers (IGMs) to determine the current node count on read, which can save API quota and speed up plans on large clusters. Unlike Terraform core's lifecycle { ignoreChanges = [nodeCount] }, this allows configuration-driven scaling updates in your HCL while still ignoring runtime autoscaling drift.
latefinal
initialNodeCount ↔ Output<int?>: The number of nodes to create in this cluster's default node pool. In regional or multi-zonal clusters, this is the number of nodes per zone. Must be set if nodePool is not set. If you're using gcp.container.NodePool objects with no default node pool, you'll need to set this to a value of at least 1, alongside setting removeDefaultNodePool to true.
latefinal
inTransitEncryptionConfig ↔ Output<String?>: Defines the config of in-transit encryption. Valid values are IN_TRANSIT_ENCRYPTION_DISABLED and IN_TRANSIT_ENCRYPTION_INTER_NODE_TRANSPARENT.
latefinal
ipAllocationPolicy ↔ Output<ClusterIpAllocationPolicy>: Configuration of cluster IP allocation for VPC-native clusters. If this block is unset during creation, it will be set by the GKE backend. Structure is documented below.
latefinal
isCustom → bool: Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool: Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool: Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool: Whether this instance represents a resource value returned over RPC.
finalinherited
labelFingerprint ↔ Output<String>: The fingerprint of the set of labels for this cluster.
latefinal
location ↔ Output<String>: The location (region or zone) in which the cluster master will be created, as well as the default node location. If you specify a zone (such as us-central1-a), the cluster will be a zonal cluster with a single cluster master. If you specify a region (such as us-west1), the cluster will be a regional cluster with multiple masters spread across zones in the region, and with default node locations in those zones as well
latefinal
loggingConfig ↔ Output<ClusterLoggingConfig>: Logging configuration for the cluster. Structure is documented below.
latefinal
loggingService ↔ Output<String>: The logging service that the cluster should write logs to. Available options include logging.googleapis.com(Legacy Stackdriver), logging.googleapis.com/kubernetes(Stackdriver Kubernetes Engine Logging), and none. Defaults to logging.googleapis.com/kubernetes
latefinal
maintenancePolicy ↔ Output<ClusterMaintenancePolicy?>: The maintenance policy to use for the cluster. Structure is documented below.
latefinal
managedMachineLearningDiagnosticsConfig ↔ Output<ClusterManagedMachineLearningDiagnosticsConfig>: ) Configuration for the GKE Managed ML Diagnostics feature. Structure is documented below.
latefinal
managedOpentelemetryConfig ↔ Output<ClusterManagedOpentelemetryConfig>: ) Configuration for the GKE Managed OpenTelemetry feature. Structure is documented below.
latefinal
masterAuth ↔ Output<ClusterMasterAuth>: The authentication information for accessing the Kubernetes master. Some values in this block are only returned by the API if your service account has permission to get credentials for your GKE cluster. If you see an unexpected diff unsetting your client cert, ensure you have the container.clusters.getCredentials permission. Structure is documented below.
latefinal
masterAuthorizedNetworksConfig ↔ Output<ClusterMasterAuthorizedNetworksConfig>: The desired configuration options for master authorized networks. Omit the nested cidrBlocks attribute to disallow external access (except the cluster node IPs, which GKE automatically whitelists). Structure is documented below.
latefinal
masterVersion ↔ Output<String>: The current version of the master in the cluster. This may be different than the minMasterVersion set in the config if the master has been updated by GKE.
latefinal
meshCertificates ↔ Output<ClusterMeshCertificates>: Structure is documented below.
latefinal
minMasterVersion ↔ Output<String?>: The minimum version of the master. GKE will auto-update the master to new versions, so this does not guarantee the current master version--use the read-only masterVersion field to obtain that. If unset, the cluster's version will be set by GKE to the version of the most recent official release (which is not necessarily the latest version). Most users will find the gcp.container.getEngineVersions data source useful - it indicates which versions are available. If you intend to specify versions manually, the docs describe the various acceptable formats for this field.
latefinal
monitoringConfig ↔ Output<ClusterMonitoringConfig>: Monitoring configuration for the cluster. Structure is documented below.
latefinal
monitoringService ↔ Output<String>: The monitoring service that the cluster should write metrics to. Automatically send metrics from pods in the cluster to the Google Cloud Monitoring API. VM metrics will be collected by Google Compute Engine regardless of this setting Available options include monitoring.googleapis.com(Legacy Stackdriver), monitoring.googleapis.com/kubernetes(Stackdriver Kubernetes Engine Monitoring), and none. Defaults to monitoring.googleapis.com/kubernetes
latefinal
name ↔ Output<String>: The name of the cluster, unique within the project and location.
latefinal
network ↔ Output<String?>: The name or selfLink of the Google Compute Engine network to which the cluster is connected. For Shared VPC, set this to the self link of the shared network.
latefinal
networkingMode ↔ Output<String>: Determines whether alias IPs or routes will be used for pod IPs in the cluster. Options are VPC_NATIVE or ROUTES. VPC_NATIVE enables IP aliasing. Newly created clusters will default to VPC_NATIVE.
latefinal
networkPerformanceConfig ↔ Output<ClusterNetworkPerformanceConfig?>: Network bandwidth tier configuration.
latefinal
networkPolicy ↔ Output<ClusterNetworkPolicy?>: Configuration options for the NetworkPolicy feature. Structure is documented below.
latefinal
nodeConfig ↔ Output<ClusterNodeConfig>: Parameters used in creating the default node pool. Generally, this field should not be used at the same time as a gcp.container.NodePool or a nodePool block; this configuration manages the default node pool, which isn't recommended to be used. Structure is documented below.
latefinal
nodeCreationConfig ↔ Output<ClusterNodeCreationConfig>: Configuration for node creation config. Structure is documented below.
latefinal
nodeLocations ↔ Output<List<String>>: The list of zones in which the cluster's nodes are located. Nodes must be in the region of their regional cluster or in the same region as their cluster's zone for zonal clusters. If this is specified for a zonal cluster, omit the cluster's zone.
latefinal
nodePoolAutoConfig ↔ Output<ClusterNodePoolAutoConfig>: Node pool configs that apply to auto-provisioned node pools in autopilot clusters and node auto-provisioning-enabled clusters. Structure is documented below.
latefinal
nodePoolDefaults ↔ Output<ClusterNodePoolDefaults>: Default NodePool settings for the entire cluster. These settings are overridden if specified on the specific NodePool object. Structure is documented below.
latefinal
nodePools ↔ Output<List<ClusterNodePool>>: List of node pools associated with this cluster. Structure is documented below. See gcp.container.NodePool for exact schema. Warning: node pools defined inside a cluster can't be changed (or added/removed) after cluster creation without deleting and recreating the entire cluster. Unless you absolutely need the ability to say "these are the only node pools associated with this cluster", use the gcp.container.NodePool resource instead of this property.
latefinal
nodeVersion ↔ Output<String>: The Kubernetes version on the nodes. Must either be unset or set to the same value as minMasterVersion on create. Defaults to the default version set by GKE which is not necessarily the latest version. This only affects nodes in the default node pool. While a fuzzy version can be specified, it's recommended that you specify explicit versions as the provider will see spurious diffs when fuzzy versions are used. See the gcp.container.getEngineVersions data source's versionPrefix field to approximate fuzzy versions. To update nodes in other node pools, use the version attribute on the node pool.
latefinal
notificationConfig ↔ Output<ClusterNotificationConfig>: Configuration for the cluster upgrade notifications feature. Structure is documented below.
latefinal
operation ↔ Output<String>: latefinal
podAutoscaling ↔ Output<ClusterPodAutoscaling>: Configuration for the Structure is documented below.
latefinal
podSecurityPolicyConfig ↔ Output<ClusterPodSecurityPolicyConfig?>: ) Configuration for the PodSecurityPolicy feature. Structure is documented below.
latefinal
privateClusterConfig ↔ Output<ClusterPrivateClusterConfig>: Configuration for private clusters, clusters with private nodes. Structure is documented below.
latefinal
privateIpv6GoogleAccess ↔ Output<String>: The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4).
latefinal
project ↔ Output<String>: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
latefinal
protectConfig ↔ Output<ClusterProtectConfig>: ) Enable/Disable Protect API features for the cluster. Structure is documented below.
latefinal
pulumiLabels ↔ Output<Map<String, String>>: The combination of labels configured directly on the resource and default labels configured on the provider.
latefinal
rbacBindingConfig ↔ Output<ClusterRbacBindingConfig>: RBACBindingConfig allows user to restrict ClusterRoleBindings an RoleBindings that can be created. Structure is documented below.
latefinal
releaseChannel ↔ Output<ClusterReleaseChannel>: Configuration options for the Release channel feature, which provide more control over automatic upgrades of your GKE clusters. When updating this field, GKE imposes specific version requirements. See Selecting a new release channel for more details; the gcp.container.getEngineVersions datasource can provide the default version for a channel. Note that removing the releaseChannel field from your config will cause the provider to stop managing your cluster's release channel, but will not unenroll it. Instead, use the "UNSPECIFIED" channel. Structure is documented below.
latefinal
removeDefaultNodePool ↔ Output<bool?>: If true, deletes the default node pool upon cluster creation. If you're using gcp.container.NodePool resources with no default node pool, this should be set to true, alongside setting initialNodeCount to at least 1.
latefinal
resourceLabels ↔ Output<Map<String, String>?>: The GCE resource labels (a map of key/value pairs) to be applied to the cluster.
latefinal
resourceTransforms → List<ResourceTransform>: Inherited/explicit async transforms.
no setterinherited
resourceUsageExportConfig ↔ Output<ClusterResourceUsageExportConfig?>: Configuration for the ResourceUsageExportConfig feature. Structure is documented below.
latefinal
rollbackSafeUpgrade ↔ Output<ClusterRollbackSafeUpgrade?>: Configuration for rollback-safe (two-step) upgrades. Structure is documented below.
latefinal
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
secretManagerConfig ↔ Output<ClusterSecretManagerConfig?>: Configuration for the SecretManagerConfig feature. Structure is documented below.
latefinal
secretSyncConfig ↔ Output<ClusterSecretSyncConfig?>: Configuration for the SecretSyncConfig feature. Structure is documented below.
latefinal
securityPostureConfig ↔ Output<ClusterSecurityPostureConfig>: Enable/Disable Security Posture API features for the cluster. Structure is documented below.
latefinal
selfLink ↔ Output<String>: The server-defined URL for the resource.
latefinal
serviceExternalIpsConfig ↔ Output<ClusterServiceExternalIpsConfig>: Structure is documented below.
latefinal
servicesIpv4Cidr ↔ Output<String>: The IP address range of the Kubernetes services in this cluster, in CIDR notation (e.g. 1.2.3.4/29). Service addresses are typically put in the last /16 from the container CIDR.
latefinal
skipNodePoolRefresh ↔ Output<bool?>: Whether to skip refreshing the GKE cluster's inline node pool list during read operations. Setting this to true prevents the provider from querying GKE API for node pools, resolving long plan times on clusters with a large number of node pools. Warning: When enabled, the cluster's nodePool attribute in the Terraform state will remain empty ([]), even if node pools exist externally. This flag cannot be set to true if you define inline nodePool blocks in your configuration; doing so will result in a validation error during plan.
latefinal
subnetwork ↔ Output<String>: The name or selfLink of the Google Compute Engine subnetwork in which the cluster's instances are launched.
latefinal
tpuConfig ↔ Output<ClusterTpuConfig>: TPU configuration for the cluster.
latefinal
tpuIpv4CidrBlock ↔ Output<String>: The IP address range of the Cloud TPUs in this cluster, in CIDR notation (e.g. 1.2.3.4/29).
latefinal
transformations → List<ResourceTransformation>: Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>: latefinalinherited
userManagedKeysConfig ↔ Output<ClusterUserManagedKeysConfig?>: The custom keys configuration of the cluster Structure is documented below.
latefinal
verticalPodAutoscaling ↔ Output<ClusterVerticalPodAutoscaling>: Vertical Pod Autoscaling automatically adjusts the resources of pods controlled by it. Structure is documented below.
latefinal
workloadAltsConfig ↔ Output<ClusterWorkloadAltsConfig>: ) Configuration for direct-path (via ALTS) with workload identity.. Structure is documented below.
latefinal
workloadIdentityConfig ↔ Output<ClusterWorkloadIdentityConfig>: Workload Identity allows Kubernetes service accounts to act as a user-managed Google IAM Service Account. Structure is documented below.
latefinal

Methods

failId(Object error) → void: Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void: Completes all output properties with error.
inherited
failUrn(Object error) → void: Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?: Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String: Returns this resource's logical name.
inherited
getResourceType() → String: Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>: Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void: Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void: Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void: Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>: Serializes resource properties for RPC transmission.
inherited
toString() → String: A string representation of this object.
inherited

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ClusterState? state, CustomResourceOptions? options}) → Cluster: Gets an existing Cluster resource's state with the given name and id.