gcp.container.Cluster

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=gcp.container.NodePoolNodeConfigArgs(
        preemptible=True,
        machine_type="e2-medium",
        service_account=default.email,
        oauth_scopes=["https://www.googleapis.com/auth/cloud-platform"],
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v7/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
		}
		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
	})
}

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 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.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = 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

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=gcp.container.ClusterNodeConfigArgs(
        service_account=default.email,
        oauth_scopes=["https://www.googleapis.com/auth/cloud-platform"],
        labels={
            "foo": "bar",
        },
        tags=[
            "foo",
            "bar",
        ],
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v7/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"),
			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
	})
}

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 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.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = 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

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)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
	"github.com/pulumi/pulumi-gcp/sdk/v7/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
	})
}

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 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.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = 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

var gcpClusterResource = new Gcp.Container.Cluster("gcpClusterResource", new()
{
    AddonsConfig = new Gcp.Container.Inputs.ClusterAddonsConfigArgs
    {
        CloudrunConfig = new Gcp.Container.Inputs.ClusterAddonsConfigCloudrunConfigArgs
        {
            Disabled = false,
            LoadBalancerType = "string",
        },
        ConfigConnectorConfig = new Gcp.Container.Inputs.ClusterAddonsConfigConfigConnectorConfigArgs
        {
            Enabled = false,
        },
        DnsCacheConfig = new Gcp.Container.Inputs.ClusterAddonsConfigDnsCacheConfigArgs
        {
            Enabled = false,
        },
        GcePersistentDiskCsiDriverConfig = new Gcp.Container.Inputs.ClusterAddonsConfigGcePersistentDiskCsiDriverConfigArgs
        {
            Enabled = false,
        },
        GcpFilestoreCsiDriverConfig = new Gcp.Container.Inputs.ClusterAddonsConfigGcpFilestoreCsiDriverConfigArgs
        {
            Enabled = false,
        },
        GcsFuseCsiDriverConfig = new Gcp.Container.Inputs.ClusterAddonsConfigGcsFuseCsiDriverConfigArgs
        {
            Enabled = false,
        },
        GkeBackupAgentConfig = new Gcp.Container.Inputs.ClusterAddonsConfigGkeBackupAgentConfigArgs
        {
            Enabled = false,
        },
        HorizontalPodAutoscaling = new Gcp.Container.Inputs.ClusterAddonsConfigHorizontalPodAutoscalingArgs
        {
            Disabled = false,
        },
        HttpLoadBalancing = new Gcp.Container.Inputs.ClusterAddonsConfigHttpLoadBalancingArgs
        {
            Disabled = false,
        },
        IstioConfig = new Gcp.Container.Inputs.ClusterAddonsConfigIstioConfigArgs
        {
            Disabled = false,
            Auth = "string",
        },
        KalmConfig = new Gcp.Container.Inputs.ClusterAddonsConfigKalmConfigArgs
        {
            Enabled = false,
        },
        NetworkPolicyConfig = new Gcp.Container.Inputs.ClusterAddonsConfigNetworkPolicyConfigArgs
        {
            Disabled = false,
        },
        StatefulHaConfig = new Gcp.Container.Inputs.ClusterAddonsConfigStatefulHaConfigArgs
        {
            Enabled = false,
        },
    },
    AllowNetAdmin = false,
    AuthenticatorGroupsConfig = new Gcp.Container.Inputs.ClusterAuthenticatorGroupsConfigArgs
    {
        SecurityGroup = "string",
    },
    BinaryAuthorization = new Gcp.Container.Inputs.ClusterBinaryAuthorizationArgs
    {
        EvaluationMode = "string",
    },
    ClusterAutoscaling = new Gcp.Container.Inputs.ClusterClusterAutoscalingArgs
    {
        AutoProvisioningDefaults = new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsArgs
        {
            BootDiskKmsKey = "string",
            DiskSize = 0,
            DiskType = "string",
            ImageType = "string",
            Management = new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsManagementArgs
            {
                AutoRepair = false,
                AutoUpgrade = false,
                UpgradeOptions = new[]
                {
                    new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsManagementUpgradeOptionArgs
                    {
                        AutoUpgradeStartTime = "string",
                        Description = "string",
                    },
                },
            },
            MinCpuPlatform = "string",
            OauthScopes = new[]
            {
                "string",
            },
            ServiceAccount = "string",
            ShieldedInstanceConfig = new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsShieldedInstanceConfigArgs
            {
                EnableIntegrityMonitoring = false,
                EnableSecureBoot = false,
            },
            UpgradeSettings = new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsUpgradeSettingsArgs
            {
                BlueGreenSettings = new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsUpgradeSettingsBlueGreenSettingsArgs
                {
                    NodePoolSoakDuration = "string",
                    StandardRolloutPolicy = new Gcp.Container.Inputs.ClusterClusterAutoscalingAutoProvisioningDefaultsUpgradeSettingsBlueGreenSettingsStandardRolloutPolicyArgs
                    {
                        BatchNodeCount = 0,
                        BatchPercentage = 0,
                        BatchSoakDuration = "string",
                    },
                },
                MaxSurge = 0,
                MaxUnavailable = 0,
                Strategy = "string",
            },
        },
        AutoscalingProfile = "string",
        Enabled = false,
        ResourceLimits = new[]
        {
            new Gcp.Container.Inputs.ClusterClusterAutoscalingResourceLimitArgs
            {
                ResourceType = "string",
                Maximum = 0,
                Minimum = 0,
            },
        },
    },
    ClusterIpv4Cidr = "string",
    ClusterTelemetry = new Gcp.Container.Inputs.ClusterClusterTelemetryArgs
    {
        Type = "string",
    },
    ConfidentialNodes = new Gcp.Container.Inputs.ClusterConfidentialNodesArgs
    {
        Enabled = false,
    },
    CostManagementConfig = new Gcp.Container.Inputs.ClusterCostManagementConfigArgs
    {
        Enabled = false,
    },
    DatabaseEncryption = new Gcp.Container.Inputs.ClusterDatabaseEncryptionArgs
    {
        State = "string",
        KeyName = "string",
    },
    DatapathProvider = "string",
    DefaultMaxPodsPerNode = 0,
    DefaultSnatStatus = new Gcp.Container.Inputs.ClusterDefaultSnatStatusArgs
    {
        Disabled = false,
    },
    DeletionProtection = false,
    Description = "string",
    DnsConfig = new Gcp.Container.Inputs.ClusterDnsConfigArgs
    {
        ClusterDns = "string",
        ClusterDnsDomain = "string",
        ClusterDnsScope = "string",
    },
    EnableAutopilot = false,
    EnableCiliumClusterwideNetworkPolicy = false,
    EnableFqdnNetworkPolicy = false,
    EnableIntranodeVisibility = false,
    EnableK8sBetaApis = new Gcp.Container.Inputs.ClusterEnableK8sBetaApisArgs
    {
        EnabledApis = new[]
        {
            "string",
        },
    },
    EnableKubernetesAlpha = false,
    EnableL4IlbSubsetting = false,
    EnableLegacyAbac = false,
    EnableMultiNetworking = false,
    EnableShieldedNodes = false,
    EnableTpu = false,
    Fleet = new Gcp.Container.Inputs.ClusterFleetArgs
    {
        Membership = "string",
        MembershipId = "string",
        MembershipLocation = "string",
        PreRegistered = false,
        Project = "string",
    },
    GatewayApiConfig = new Gcp.Container.Inputs.ClusterGatewayApiConfigArgs
    {
        Channel = "string",
    },
    IdentityServiceConfig = new Gcp.Container.Inputs.ClusterIdentityServiceConfigArgs
    {
        Enabled = false,
    },
    InitialNodeCount = 0,
    IpAllocationPolicy = new Gcp.Container.Inputs.ClusterIpAllocationPolicyArgs
    {
        AdditionalPodRangesConfig = new Gcp.Container.Inputs.ClusterIpAllocationPolicyAdditionalPodRangesConfigArgs
        {
            PodRangeNames = new[]
            {
                "string",
            },
        },
        ClusterIpv4CidrBlock = "string",
        ClusterSecondaryRangeName = "string",
        PodCidrOverprovisionConfig = new Gcp.Container.Inputs.ClusterIpAllocationPolicyPodCidrOverprovisionConfigArgs
        {
            Disabled = false,
        },
        ServicesIpv4CidrBlock = "string",
        ServicesSecondaryRangeName = "string",
        StackType = "string",
    },
    Location = "string",
    LoggingConfig = new Gcp.Container.Inputs.ClusterLoggingConfigArgs
    {
        EnableComponents = new[]
        {
            "string",
        },
    },
    LoggingService = "string",
    MaintenancePolicy = new Gcp.Container.Inputs.ClusterMaintenancePolicyArgs
    {
        DailyMaintenanceWindow = new Gcp.Container.Inputs.ClusterMaintenancePolicyDailyMaintenanceWindowArgs
        {
            StartTime = "string",
            Duration = "string",
        },
        MaintenanceExclusions = new[]
        {
            new Gcp.Container.Inputs.ClusterMaintenancePolicyMaintenanceExclusionArgs
            {
                EndTime = "string",
                ExclusionName = "string",
                StartTime = "string",
                ExclusionOptions = new Gcp.Container.Inputs.ClusterMaintenancePolicyMaintenanceExclusionExclusionOptionsArgs
                {
                    Scope = "string",
                },
            },
        },
        RecurringWindow = new Gcp.Container.Inputs.ClusterMaintenancePolicyRecurringWindowArgs
        {
            EndTime = "string",
            Recurrence = "string",
            StartTime = "string",
        },
    },
    MasterAuth = new Gcp.Container.Inputs.ClusterMasterAuthArgs
    {
        ClientCertificateConfig = new Gcp.Container.Inputs.ClusterMasterAuthClientCertificateConfigArgs
        {
            IssueClientCertificate = false,
        },
        ClientCertificate = "string",
        ClientKey = "string",
        ClusterCaCertificate = "string",
    },
    MasterAuthorizedNetworksConfig = new Gcp.Container.Inputs.ClusterMasterAuthorizedNetworksConfigArgs
    {
        CidrBlocks = new[]
        {
            new Gcp.Container.Inputs.ClusterMasterAuthorizedNetworksConfigCidrBlockArgs
            {
                CidrBlock = "string",
                DisplayName = "string",
            },
        },
        GcpPublicCidrsAccessEnabled = false,
    },
    MeshCertificates = new Gcp.Container.Inputs.ClusterMeshCertificatesArgs
    {
        EnableCertificates = false,
    },
    MinMasterVersion = "string",
    MonitoringConfig = new Gcp.Container.Inputs.ClusterMonitoringConfigArgs
    {
        AdvancedDatapathObservabilityConfigs = new[]
        {
            new Gcp.Container.Inputs.ClusterMonitoringConfigAdvancedDatapathObservabilityConfigArgs
            {
                EnableMetrics = false,
                EnableRelay = false,
            },
        },
        EnableComponents = new[]
        {
            "string",
        },
        ManagedPrometheus = new Gcp.Container.Inputs.ClusterMonitoringConfigManagedPrometheusArgs
        {
            Enabled = false,
        },
    },
    MonitoringService = "string",
    Name = "string",
    Network = "string",
    NetworkPolicy = new Gcp.Container.Inputs.ClusterNetworkPolicyArgs
    {
        Enabled = false,
        Provider = "string",
    },
    NetworkingMode = "string",
    NodeConfig = new Gcp.Container.Inputs.ClusterNodeConfigArgs
    {
        AdvancedMachineFeatures = new Gcp.Container.Inputs.ClusterNodeConfigAdvancedMachineFeaturesArgs
        {
            ThreadsPerCore = 0,
        },
        BootDiskKmsKey = "string",
        ConfidentialNodes = new Gcp.Container.Inputs.ClusterNodeConfigConfidentialNodesArgs
        {
            Enabled = false,
        },
        DiskSizeGb = 0,
        DiskType = "string",
        EffectiveTaints = new[]
        {
            new Gcp.Container.Inputs.ClusterNodeConfigEffectiveTaintArgs
            {
                Effect = "string",
                Key = "string",
                Value = "string",
            },
        },
        EnableConfidentialStorage = false,
        EphemeralStorageConfig = new Gcp.Container.Inputs.ClusterNodeConfigEphemeralStorageConfigArgs
        {
            LocalSsdCount = 0,
        },
        EphemeralStorageLocalSsdConfig = new Gcp.Container.Inputs.ClusterNodeConfigEphemeralStorageLocalSsdConfigArgs
        {
            LocalSsdCount = 0,
        },
        FastSocket = new Gcp.Container.Inputs.ClusterNodeConfigFastSocketArgs
        {
            Enabled = false,
        },
        GcfsConfig = new Gcp.Container.Inputs.ClusterNodeConfigGcfsConfigArgs
        {
            Enabled = false,
        },
        GuestAccelerators = new[]
        {
            new Gcp.Container.Inputs.ClusterNodeConfigGuestAcceleratorArgs
            {
                Count = 0,
                Type = "string",
                GpuDriverInstallationConfig = new Gcp.Container.Inputs.ClusterNodeConfigGuestAcceleratorGpuDriverInstallationConfigArgs
                {
                    GpuDriverVersion = "string",
                },
                GpuPartitionSize = "string",
                GpuSharingConfig = new Gcp.Container.Inputs.ClusterNodeConfigGuestAcceleratorGpuSharingConfigArgs
                {
                    GpuSharingStrategy = "string",
                    MaxSharedClientsPerGpu = 0,
                },
            },
        },
        Gvnic = new Gcp.Container.Inputs.ClusterNodeConfigGvnicArgs
        {
            Enabled = false,
        },
        HostMaintenancePolicy = new Gcp.Container.Inputs.ClusterNodeConfigHostMaintenancePolicyArgs
        {
            MaintenanceInterval = "string",
        },
        ImageType = "string",
        KubeletConfig = new Gcp.Container.Inputs.ClusterNodeConfigKubeletConfigArgs
        {
            CpuManagerPolicy = "string",
            CpuCfsQuota = false,
            CpuCfsQuotaPeriod = "string",
            PodPidsLimit = 0,
        },
        Labels = 
        {
            { "string", "string" },
        },
        LinuxNodeConfig = new Gcp.Container.Inputs.ClusterNodeConfigLinuxNodeConfigArgs
        {
            CgroupMode = "string",
            Sysctls = 
            {
                { "string", "string" },
            },
        },
        LocalNvmeSsdBlockConfig = new Gcp.Container.Inputs.ClusterNodeConfigLocalNvmeSsdBlockConfigArgs
        {
            LocalSsdCount = 0,
        },
        LocalSsdCount = 0,
        LoggingVariant = "string",
        MachineType = "string",
        Metadata = 
        {
            { "string", "string" },
        },
        MinCpuPlatform = "string",
        NodeGroup = "string",
        OauthScopes = new[]
        {
            "string",
        },
        Preemptible = false,
        ReservationAffinity = new Gcp.Container.Inputs.ClusterNodeConfigReservationAffinityArgs
        {
            ConsumeReservationType = "string",
            Key = "string",
            Values = new[]
            {
                "string",
            },
        },
        ResourceLabels = 
        {
            { "string", "string" },
        },
        ResourceManagerTags = 
        {
            { "string", "any" },
        },
        SandboxConfig = new Gcp.Container.Inputs.ClusterNodeConfigSandboxConfigArgs
        {
            SandboxType = "string",
        },
        ServiceAccount = "string",
        ShieldedInstanceConfig = new Gcp.Container.Inputs.ClusterNodeConfigShieldedInstanceConfigArgs
        {
            EnableIntegrityMonitoring = false,
            EnableSecureBoot = false,
        },
        SoleTenantConfig = new Gcp.Container.Inputs.ClusterNodeConfigSoleTenantConfigArgs
        {
            NodeAffinities = new[]
            {
                new Gcp.Container.Inputs.ClusterNodeConfigSoleTenantConfigNodeAffinityArgs
                {
                    Key = "string",
                    Operator = "string",
                    Values = new[]
                    {
                        "string",
                    },
                },
            },
        },
        Spot = false,
        Tags = new[]
        {
            "string",
        },
        Taints = new[]
        {
            new Gcp.Container.Inputs.ClusterNodeConfigTaintArgs
            {
                Effect = "string",
                Key = "string",
                Value = "string",
            },
        },
        WorkloadMetadataConfig = new Gcp.Container.Inputs.ClusterNodeConfigWorkloadMetadataConfigArgs
        {
            Mode = "string",
        },
    },
    NodeLocations = new[]
    {
        "string",
    },
    NodePoolAutoConfig = new Gcp.Container.Inputs.ClusterNodePoolAutoConfigArgs
    {
        NetworkTags = new Gcp.Container.Inputs.ClusterNodePoolAutoConfigNetworkTagsArgs
        {
            Tags = new[]
            {
                "string",
            },
        },
        ResourceManagerTags = 
        {
            { "string", "any" },
        },
    },
    NodePoolDefaults = new Gcp.Container.Inputs.ClusterNodePoolDefaultsArgs
    {
        NodeConfigDefaults = new Gcp.Container.Inputs.ClusterNodePoolDefaultsNodeConfigDefaultsArgs
        {
            GcfsConfig = new Gcp.Container.Inputs.ClusterNodePoolDefaultsNodeConfigDefaultsGcfsConfigArgs
            {
                Enabled = false,
            },
            LoggingVariant = "string",
        },
    },
    NodePools = new[]
    {
        new Gcp.Container.Inputs.ClusterNodePoolArgs
        {
            Autoscaling = new Gcp.Container.Inputs.ClusterNodePoolAutoscalingArgs
            {
                LocationPolicy = "string",
                MaxNodeCount = 0,
                MinNodeCount = 0,
                TotalMaxNodeCount = 0,
                TotalMinNodeCount = 0,
            },
            InitialNodeCount = 0,
            InstanceGroupUrls = new[]
            {
                "string",
            },
            ManagedInstanceGroupUrls = new[]
            {
                "string",
            },
            Management = new Gcp.Container.Inputs.ClusterNodePoolManagementArgs
            {
                AutoRepair = false,
                AutoUpgrade = false,
            },
            MaxPodsPerNode = 0,
            Name = "string",
            NamePrefix = "string",
            NetworkConfig = new Gcp.Container.Inputs.ClusterNodePoolNetworkConfigArgs
            {
                AdditionalNodeNetworkConfigs = new[]
                {
                    new Gcp.Container.Inputs.ClusterNodePoolNetworkConfigAdditionalNodeNetworkConfigArgs
                    {
                        Network = "string",
                        Subnetwork = "string",
                    },
                },
                AdditionalPodNetworkConfigs = new[]
                {
                    new Gcp.Container.Inputs.ClusterNodePoolNetworkConfigAdditionalPodNetworkConfigArgs
                    {
                        MaxPodsPerNode = 0,
                        SecondaryPodRange = "string",
                        Subnetwork = "string",
                    },
                },
                CreatePodRange = false,
                EnablePrivateNodes = false,
                NetworkPerformanceConfig = new Gcp.Container.Inputs.ClusterNodePoolNetworkConfigNetworkPerformanceConfigArgs
                {
                    TotalEgressBandwidthTier = "string",
                },
                PodCidrOverprovisionConfig = new Gcp.Container.Inputs.ClusterNodePoolNetworkConfigPodCidrOverprovisionConfigArgs
                {
                    Disabled = false,
                },
                PodIpv4CidrBlock = "string",
                PodRange = "string",
            },
            NodeConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigArgs
            {
                AdvancedMachineFeatures = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigAdvancedMachineFeaturesArgs
                {
                    ThreadsPerCore = 0,
                },
                BootDiskKmsKey = "string",
                ConfidentialNodes = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigConfidentialNodesArgs
                {
                    Enabled = false,
                },
                DiskSizeGb = 0,
                DiskType = "string",
                EffectiveTaints = new[]
                {
                    new Gcp.Container.Inputs.ClusterNodePoolNodeConfigEffectiveTaintArgs
                    {
                        Effect = "string",
                        Key = "string",
                        Value = "string",
                    },
                },
                EnableConfidentialStorage = false,
                EphemeralStorageConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigEphemeralStorageConfigArgs
                {
                    LocalSsdCount = 0,
                },
                EphemeralStorageLocalSsdConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigEphemeralStorageLocalSsdConfigArgs
                {
                    LocalSsdCount = 0,
                },
                FastSocket = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigFastSocketArgs
                {
                    Enabled = false,
                },
                GcfsConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigGcfsConfigArgs
                {
                    Enabled = false,
                },
                GuestAccelerators = new[]
                {
                    new Gcp.Container.Inputs.ClusterNodePoolNodeConfigGuestAcceleratorArgs
                    {
                        Count = 0,
                        Type = "string",
                        GpuDriverInstallationConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigGuestAcceleratorGpuDriverInstallationConfigArgs
                        {
                            GpuDriverVersion = "string",
                        },
                        GpuPartitionSize = "string",
                        GpuSharingConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigGuestAcceleratorGpuSharingConfigArgs
                        {
                            GpuSharingStrategy = "string",
                            MaxSharedClientsPerGpu = 0,
                        },
                    },
                },
                Gvnic = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigGvnicArgs
                {
                    Enabled = false,
                },
                HostMaintenancePolicy = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigHostMaintenancePolicyArgs
                {
                    MaintenanceInterval = "string",
                },
                ImageType = "string",
                KubeletConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigKubeletConfigArgs
                {
                    CpuManagerPolicy = "string",
                    CpuCfsQuota = false,
                    CpuCfsQuotaPeriod = "string",
                    PodPidsLimit = 0,
                },
                Labels = 
                {
                    { "string", "string" },
                },
                LinuxNodeConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigLinuxNodeConfigArgs
                {
                    CgroupMode = "string",
                    Sysctls = 
                    {
                        { "string", "string" },
                    },
                },
                LocalNvmeSsdBlockConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigArgs
                {
                    LocalSsdCount = 0,
                },
                LocalSsdCount = 0,
                LoggingVariant = "string",
                MachineType = "string",
                Metadata = 
                {
                    { "string", "string" },
                },
                MinCpuPlatform = "string",
                NodeGroup = "string",
                OauthScopes = new[]
                {
                    "string",
                },
                Preemptible = false,
                ReservationAffinity = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigReservationAffinityArgs
                {
                    ConsumeReservationType = "string",
                    Key = "string",
                    Values = new[]
                    {
                        "string",
                    },
                },
                ResourceLabels = 
                {
                    { "string", "string" },
                },
                ResourceManagerTags = 
                {
                    { "string", "any" },
                },
                SandboxConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigSandboxConfigArgs
                {
                    SandboxType = "string",
                },
                ServiceAccount = "string",
                ShieldedInstanceConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigShieldedInstanceConfigArgs
                {
                    EnableIntegrityMonitoring = false,
                    EnableSecureBoot = false,
                },
                SoleTenantConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigSoleTenantConfigArgs
                {
                    NodeAffinities = new[]
                    {
                        new Gcp.Container.Inputs.ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityArgs
                        {
                            Key = "string",
                            Operator = "string",
                            Values = new[]
                            {
                                "string",
                            },
                        },
                    },
                },
                Spot = false,
                Tags = new[]
                {
                    "string",
                },
                Taints = new[]
                {
                    new Gcp.Container.Inputs.ClusterNodePoolNodeConfigTaintArgs
                    {
                        Effect = "string",
                        Key = "string",
                        Value = "string",
                    },
                },
                WorkloadMetadataConfig = new Gcp.Container.Inputs.ClusterNodePoolNodeConfigWorkloadMetadataConfigArgs
                {
                    Mode = "string",
                },
            },
            NodeCount = 0,
            NodeLocations = new[]
            {
                "string",
            },
            PlacementPolicy = new Gcp.Container.Inputs.ClusterNodePoolPlacementPolicyArgs
            {
                Type = "string",
                PolicyName = "string",
                TpuTopology = "string",
            },
            QueuedProvisioning = new Gcp.Container.Inputs.ClusterNodePoolQueuedProvisioningArgs
            {
                Enabled = false,
            },
            UpgradeSettings = new Gcp.Container.Inputs.ClusterNodePoolUpgradeSettingsArgs
            {
                BlueGreenSettings = new Gcp.Container.Inputs.ClusterNodePoolUpgradeSettingsBlueGreenSettingsArgs
                {
                    StandardRolloutPolicy = new Gcp.Container.Inputs.ClusterNodePoolUpgradeSettingsBlueGreenSettingsStandardRolloutPolicyArgs
                    {
                        BatchNodeCount = 0,
                        BatchPercentage = 0,
                        BatchSoakDuration = "string",
                    },
                    NodePoolSoakDuration = "string",
                },
                MaxSurge = 0,
                MaxUnavailable = 0,
                Strategy = "string",
            },
            Version = "string",
        },
    },
    NodeVersion = "string",
    NotificationConfig = new Gcp.Container.Inputs.ClusterNotificationConfigArgs
    {
        Pubsub = new Gcp.Container.Inputs.ClusterNotificationConfigPubsubArgs
        {
            Enabled = false,
            Filter = new Gcp.Container.Inputs.ClusterNotificationConfigPubsubFilterArgs
            {
                EventTypes = new[]
                {
                    "string",
                },
            },
            Topic = "string",
        },
    },
    PodSecurityPolicyConfig = new Gcp.Container.Inputs.ClusterPodSecurityPolicyConfigArgs
    {
        Enabled = false,
    },
    PrivateClusterConfig = new Gcp.Container.Inputs.ClusterPrivateClusterConfigArgs
    {
        EnablePrivateEndpoint = false,
        EnablePrivateNodes = false,
        MasterGlobalAccessConfig = new Gcp.Container.Inputs.ClusterPrivateClusterConfigMasterGlobalAccessConfigArgs
        {
            Enabled = false,
        },
        MasterIpv4CidrBlock = "string",
        PeeringName = "string",
        PrivateEndpoint = "string",
        PrivateEndpointSubnetwork = "string",
        PublicEndpoint = "string",
    },
    PrivateIpv6GoogleAccess = "string",
    Project = "string",
    ProtectConfig = new Gcp.Container.Inputs.ClusterProtectConfigArgs
    {
        WorkloadConfig = new Gcp.Container.Inputs.ClusterProtectConfigWorkloadConfigArgs
        {
            AuditMode = "string",
        },
        WorkloadVulnerabilityMode = "string",
    },
    ReleaseChannel = new Gcp.Container.Inputs.ClusterReleaseChannelArgs
    {
        Channel = "string",
    },
    RemoveDefaultNodePool = false,
    ResourceLabels = 
    {
        { "string", "string" },
    },
    ResourceUsageExportConfig = new Gcp.Container.Inputs.ClusterResourceUsageExportConfigArgs
    {
        BigqueryDestination = new Gcp.Container.Inputs.ClusterResourceUsageExportConfigBigqueryDestinationArgs
        {
            DatasetId = "string",
        },
        EnableNetworkEgressMetering = false,
        EnableResourceConsumptionMetering = false,
    },
    SecurityPostureConfig = new Gcp.Container.Inputs.ClusterSecurityPostureConfigArgs
    {
        Mode = "string",
        VulnerabilityMode = "string",
    },
    ServiceExternalIpsConfig = new Gcp.Container.Inputs.ClusterServiceExternalIpsConfigArgs
    {
        Enabled = false,
    },
    Subnetwork = "string",
    TpuConfig = new Gcp.Container.Inputs.ClusterTpuConfigArgs
    {
        Enabled = false,
        Ipv4CidrBlock = "string",
        UseServiceNetworking = false,
    },
    VerticalPodAutoscaling = new Gcp.Container.Inputs.ClusterVerticalPodAutoscalingArgs
    {
        Enabled = false,
    },
    WorkloadAltsConfig = new Gcp.Container.Inputs.ClusterWorkloadAltsConfigArgs
    {
        EnableAlts = false,
    },
    WorkloadIdentityConfig = new Gcp.Container.Inputs.ClusterWorkloadIdentityConfigArgs
    {
        WorkloadPool = "string",
    },
});