All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.gcp.gkeonprem.kotlin.BareMetalAdminCluster.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 8.13.1.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.gkeonprem.kotlin

import com.pulumi.core.Output
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterClusterOperations
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterControlPlane
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterFleet
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterLoadBalancer
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterMaintenanceConfig
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterNetworkConfig
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterNodeAccessConfig
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterNodeConfig
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterProxy
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterSecurityConfig
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterStatus
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterStorage
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterValidationCheck
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterClusterOperations.Companion.toKotlin as bareMetalAdminClusterClusterOperationsToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterControlPlane.Companion.toKotlin as bareMetalAdminClusterControlPlaneToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterFleet.Companion.toKotlin as bareMetalAdminClusterFleetToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterLoadBalancer.Companion.toKotlin as bareMetalAdminClusterLoadBalancerToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterMaintenanceConfig.Companion.toKotlin as bareMetalAdminClusterMaintenanceConfigToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterNetworkConfig.Companion.toKotlin as bareMetalAdminClusterNetworkConfigToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterNodeAccessConfig.Companion.toKotlin as bareMetalAdminClusterNodeAccessConfigToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterNodeConfig.Companion.toKotlin as bareMetalAdminClusterNodeConfigToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterProxy.Companion.toKotlin as bareMetalAdminClusterProxyToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterSecurityConfig.Companion.toKotlin as bareMetalAdminClusterSecurityConfigToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterStatus.Companion.toKotlin as bareMetalAdminClusterStatusToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterStorage.Companion.toKotlin as bareMetalAdminClusterStorageToKotlin
import com.pulumi.gcp.gkeonprem.kotlin.outputs.BareMetalAdminClusterValidationCheck.Companion.toKotlin as bareMetalAdminClusterValidationCheckToKotlin

/**
 * Builder for [BareMetalAdminCluster].
 */
@PulumiTagMarker
public class BareMetalAdminClusterResourceBuilder internal constructor() {
    public var name: String? = null

    public var args: BareMetalAdminClusterArgs = BareMetalAdminClusterArgs()

    public var opts: CustomResourceOptions = CustomResourceOptions()

    /**
     * @param name The _unique_ name of the resulting resource.
     */
    public fun name(`value`: String) {
        this.name = value
    }

    /**
     * @param block The arguments to use to populate this resource's properties.
     */
    public suspend fun args(block: suspend BareMetalAdminClusterArgsBuilder.() -> Unit) {
        val builder = BareMetalAdminClusterArgsBuilder()
        block(builder)
        this.args = builder.build()
    }

    /**
     * @param block A bag of options that control this resource's behavior.
     */
    public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
        this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
    }

    internal fun build(): BareMetalAdminCluster {
        val builtJavaResource = com.pulumi.gcp.gkeonprem.BareMetalAdminCluster(
            this.name,
            this.args.toJava(),
            this.opts.toJava(),
        )
        return BareMetalAdminCluster(builtJavaResource)
    }
}

/**
 * A Google Bare Metal Admin Cluster.
 * ## Example Usage
 * ### Gkeonprem Bare Metal Admin Cluster Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const admin_cluster_basic = new gcp.gkeonprem.BareMetalAdminCluster("admin-cluster-basic", {
 *     name: "my-cluster",
 *     location: "us-west1",
 *     bareMetalVersion: "1.13.4",
 *     networkConfig: {
 *         islandModeCidr: {
 *             serviceAddressCidrBlocks: ["172.26.0.0/16"],
 *             podAddressCidrBlocks: ["10.240.0.0/13"],
 *         },
 *     },
 *     nodeConfig: {
 *         maxPodsPerNode: 250,
 *     },
 *     controlPlane: {
 *         controlPlaneNodePoolConfig: {
 *             nodePoolConfig: {
 *                 labels: {},
 *                 operatingSystem: "LINUX",
 *                 nodeConfigs: [
 *                     {
 *                         labels: {},
 *                         nodeIp: "10.200.0.2",
 *                     },
 *                     {
 *                         labels: {},
 *                         nodeIp: "10.200.0.3",
 *                     },
 *                     {
 *                         labels: {},
 *                         nodeIp: "10.200.0.4",
 *                     },
 *                 ],
 *             },
 *         },
 *     },
 *     loadBalancer: {
 *         portConfig: {
 *             controlPlaneLoadBalancerPort: 443,
 *         },
 *         vipConfig: {
 *             controlPlaneVip: "10.200.0.5",
 *         },
 *     },
 *     storage: {
 *         lvpShareConfig: {
 *             lvpConfig: {
 *                 path: "/mnt/localpv-share",
 *                 storageClass: "local-shared",
 *             },
 *             sharedPathPvCount: 5,
 *         },
 *         lvpNodeMountsConfig: {
 *             path: "/mnt/localpv-disk",
 *             storageClass: "local-disks",
 *         },
 *     },
 *     nodeAccessConfig: {
 *         loginUser: "root",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * admin_cluster_basic = gcp.gkeonprem.BareMetalAdminCluster("admin-cluster-basic",
 *     name="my-cluster",
 *     location="us-west1",
 *     bare_metal_version="1.13.4",
 *     network_config={
 *         "island_mode_cidr": {
 *             "service_address_cidr_blocks": ["172.26.0.0/16"],
 *             "pod_address_cidr_blocks": ["10.240.0.0/13"],
 *         },
 *     },
 *     node_config={
 *         "max_pods_per_node": 250,
 *     },
 *     control_plane={
 *         "control_plane_node_pool_config": {
 *             "node_pool_config": {
 *                 "labels": {},
 *                 "operating_system": "LINUX",
 *                 "node_configs": [
 *                     {
 *                         "labels": {},
 *                         "node_ip": "10.200.0.2",
 *                     },
 *                     {
 *                         "labels": {},
 *                         "node_ip": "10.200.0.3",
 *                     },
 *                     {
 *                         "labels": {},
 *                         "node_ip": "10.200.0.4",
 *                     },
 *                 ],
 *             },
 *         },
 *     },
 *     load_balancer={
 *         "port_config": {
 *             "control_plane_load_balancer_port": 443,
 *         },
 *         "vip_config": {
 *             "control_plane_vip": "10.200.0.5",
 *         },
 *     },
 *     storage={
 *         "lvp_share_config": {
 *             "lvp_config": {
 *                 "path": "/mnt/localpv-share",
 *                 "storage_class": "local-shared",
 *             },
 *             "shared_path_pv_count": 5,
 *         },
 *         "lvp_node_mounts_config": {
 *             "path": "/mnt/localpv-disk",
 *             "storage_class": "local-disks",
 *         },
 *     },
 *     node_access_config={
 *         "login_user": "root",
 *     })
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var admin_cluster_basic = new Gcp.GkeOnPrem.BareMetalAdminCluster("admin-cluster-basic", new()
 *     {
 *         Name = "my-cluster",
 *         Location = "us-west1",
 *         BareMetalVersion = "1.13.4",
 *         NetworkConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNetworkConfigArgs
 *         {
 *             IslandModeCidr = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNetworkConfigIslandModeCidrArgs
 *             {
 *                 ServiceAddressCidrBlocks = new[]
 *                 {
 *                     "172.26.0.0/16",
 *                 },
 *                 PodAddressCidrBlocks = new[]
 *                 {
 *                     "10.240.0.0/13",
 *                 },
 *             },
 *         },
 *         NodeConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNodeConfigArgs
 *         {
 *             MaxPodsPerNode = 250,
 *         },
 *         ControlPlane = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneArgs
 *         {
 *             ControlPlaneNodePoolConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs
 *             {
 *                 NodePoolConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs
 *                 {
 *                     Labels = null,
 *                     OperatingSystem = "LINUX",
 *                     NodeConfigs = new[]
 *                     {
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs
 *                         {
 *                             Labels = null,
 *                             NodeIp = "10.200.0.2",
 *                         },
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs
 *                         {
 *                             Labels = null,
 *                             NodeIp = "10.200.0.3",
 *                         },
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs
 *                         {
 *                             Labels = null,
 *                             NodeIp = "10.200.0.4",
 *                         },
 *                     },
 *                 },
 *             },
 *         },
 *         LoadBalancer = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerArgs
 *         {
 *             PortConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerPortConfigArgs
 *             {
 *                 ControlPlaneLoadBalancerPort = 443,
 *             },
 *             VipConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerVipConfigArgs
 *             {
 *                 ControlPlaneVip = "10.200.0.5",
 *             },
 *         },
 *         Storage = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageArgs
 *         {
 *             LvpShareConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageLvpShareConfigArgs
 *             {
 *                 LvpConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs
 *                 {
 *                     Path = "/mnt/localpv-share",
 *                     StorageClass = "local-shared",
 *                 },
 *                 SharedPathPvCount = 5,
 *             },
 *             LvpNodeMountsConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageLvpNodeMountsConfigArgs
 *             {
 *                 Path = "/mnt/localpv-disk",
 *                 StorageClass = "local-disks",
 *             },
 *         },
 *         NodeAccessConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNodeAccessConfigArgs
 *         {
 *             LoginUser = "root",
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/gkeonprem"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := gkeonprem.NewBareMetalAdminCluster(ctx, "admin-cluster-basic", &gkeonprem.BareMetalAdminClusterArgs{
 * 			Name:             pulumi.String("my-cluster"),
 * 			Location:         pulumi.String("us-west1"),
 * 			BareMetalVersion: pulumi.String("1.13.4"),
 * 			NetworkConfig: &gkeonprem.BareMetalAdminClusterNetworkConfigArgs{
 * 				IslandModeCidr: &gkeonprem.BareMetalAdminClusterNetworkConfigIslandModeCidrArgs{
 * 					ServiceAddressCidrBlocks: pulumi.StringArray{
 * 						pulumi.String("172.26.0.0/16"),
 * 					},
 * 					PodAddressCidrBlocks: pulumi.StringArray{
 * 						pulumi.String("10.240.0.0/13"),
 * 					},
 * 				},
 * 			},
 * 			NodeConfig: &gkeonprem.BareMetalAdminClusterNodeConfigArgs{
 * 				MaxPodsPerNode: pulumi.Int(250),
 * 			},
 * 			ControlPlane: &gkeonprem.BareMetalAdminClusterControlPlaneArgs{
 * 				ControlPlaneNodePoolConfig: &gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs{
 * 					NodePoolConfig: &gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs{
 * 						Labels:          nil,
 * 						OperatingSystem: pulumi.String("LINUX"),
 * 						NodeConfigs: gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArray{
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs{
 * 								Labels: nil,
 * 								NodeIp: pulumi.String("10.200.0.2"),
 * 							},
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs{
 * 								Labels: nil,
 * 								NodeIp: pulumi.String("10.200.0.3"),
 * 							},
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs{
 * 								Labels: nil,
 * 								NodeIp: pulumi.String("10.200.0.4"),
 * 							},
 * 						},
 * 					},
 * 				},
 * 			},
 * 			LoadBalancer: &gkeonprem.BareMetalAdminClusterLoadBalancerArgs{
 * 				PortConfig: &gkeonprem.BareMetalAdminClusterLoadBalancerPortConfigArgs{
 * 					ControlPlaneLoadBalancerPort: pulumi.Int(443),
 * 				},
 * 				VipConfig: &gkeonprem.BareMetalAdminClusterLoadBalancerVipConfigArgs{
 * 					ControlPlaneVip: pulumi.String("10.200.0.5"),
 * 				},
 * 			},
 * 			Storage: &gkeonprem.BareMetalAdminClusterStorageArgs{
 * 				LvpShareConfig: &gkeonprem.BareMetalAdminClusterStorageLvpShareConfigArgs{
 * 					LvpConfig: &gkeonprem.BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs{
 * 						Path:         pulumi.String("/mnt/localpv-share"),
 * 						StorageClass: pulumi.String("local-shared"),
 * 					},
 * 					SharedPathPvCount: pulumi.Int(5),
 * 				},
 * 				LvpNodeMountsConfig: &gkeonprem.BareMetalAdminClusterStorageLvpNodeMountsConfigArgs{
 * 					Path:         pulumi.String("/mnt/localpv-disk"),
 * 					StorageClass: pulumi.String("local-disks"),
 * 				},
 * 			},
 * 			NodeAccessConfig: &gkeonprem.BareMetalAdminClusterNodeAccessConfigArgs{
 * 				LoginUser: pulumi.String("root"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.gkeonprem.BareMetalAdminCluster;
 * import com.pulumi.gcp.gkeonprem.BareMetalAdminClusterArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNetworkConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNetworkConfigIslandModeCidrArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNodeConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterControlPlaneArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerPortConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerVipConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageLvpShareConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageLvpNodeMountsConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNodeAccessConfigArgs;
 * 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 admin_cluster_basic = new BareMetalAdminCluster("admin-cluster-basic", BareMetalAdminClusterArgs.builder()
 *             .name("my-cluster")
 *             .location("us-west1")
 *             .bareMetalVersion("1.13.4")
 *             .networkConfig(BareMetalAdminClusterNetworkConfigArgs.builder()
 *                 .islandModeCidr(BareMetalAdminClusterNetworkConfigIslandModeCidrArgs.builder()
 *                     .serviceAddressCidrBlocks("172.26.0.0/16")
 *                     .podAddressCidrBlocks("10.240.0.0/13")
 *                     .build())
 *                 .build())
 *             .nodeConfig(BareMetalAdminClusterNodeConfigArgs.builder()
 *                 .maxPodsPerNode(250)
 *                 .build())
 *             .controlPlane(BareMetalAdminClusterControlPlaneArgs.builder()
 *                 .controlPlaneNodePoolConfig(BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs.builder()
 *                     .nodePoolConfig(BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs.builder()
 *                         .labels()
 *                         .operatingSystem("LINUX")
 *                         .nodeConfigs(
 *                             BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs.builder()
 *                                 .labels()
 *                                 .nodeIp("10.200.0.2")
 *                                 .build(),
 *                             BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs.builder()
 *                                 .labels()
 *                                 .nodeIp("10.200.0.3")
 *                                 .build(),
 *                             BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs.builder()
 *                                 .labels()
 *                                 .nodeIp("10.200.0.4")
 *                                 .build())
 *                         .build())
 *                     .build())
 *                 .build())
 *             .loadBalancer(BareMetalAdminClusterLoadBalancerArgs.builder()
 *                 .portConfig(BareMetalAdminClusterLoadBalancerPortConfigArgs.builder()
 *                     .controlPlaneLoadBalancerPort(443)
 *                     .build())
 *                 .vipConfig(BareMetalAdminClusterLoadBalancerVipConfigArgs.builder()
 *                     .controlPlaneVip("10.200.0.5")
 *                     .build())
 *                 .build())
 *             .storage(BareMetalAdminClusterStorageArgs.builder()
 *                 .lvpShareConfig(BareMetalAdminClusterStorageLvpShareConfigArgs.builder()
 *                     .lvpConfig(BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs.builder()
 *                         .path("/mnt/localpv-share")
 *                         .storageClass("local-shared")
 *                         .build())
 *                     .sharedPathPvCount(5)
 *                     .build())
 *                 .lvpNodeMountsConfig(BareMetalAdminClusterStorageLvpNodeMountsConfigArgs.builder()
 *                     .path("/mnt/localpv-disk")
 *                     .storageClass("local-disks")
 *                     .build())
 *                 .build())
 *             .nodeAccessConfig(BareMetalAdminClusterNodeAccessConfigArgs.builder()
 *                 .loginUser("root")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   admin-cluster-basic:
 *     type: gcp:gkeonprem:BareMetalAdminCluster
 *     properties:
 *       name: my-cluster
 *       location: us-west1
 *       bareMetalVersion: 1.13.4
 *       networkConfig:
 *         islandModeCidr:
 *           serviceAddressCidrBlocks:
 *             - 172.26.0.0/16
 *           podAddressCidrBlocks:
 *             - 10.240.0.0/13
 *       nodeConfig:
 *         maxPodsPerNode: 250
 *       controlPlane:
 *         controlPlaneNodePoolConfig:
 *           nodePoolConfig:
 *             labels: {}
 *             operatingSystem: LINUX
 *             nodeConfigs:
 *               - labels: {}
 *                 nodeIp: 10.200.0.2
 *               - labels: {}
 *                 nodeIp: 10.200.0.3
 *               - labels: {}
 *                 nodeIp: 10.200.0.4
 *       loadBalancer:
 *         portConfig:
 *           controlPlaneLoadBalancerPort: 443
 *         vipConfig:
 *           controlPlaneVip: 10.200.0.5
 *       storage:
 *         lvpShareConfig:
 *           lvpConfig:
 *             path: /mnt/localpv-share
 *             storageClass: local-shared
 *           sharedPathPvCount: 5
 *         lvpNodeMountsConfig:
 *           path: /mnt/localpv-disk
 *           storageClass: local-disks
 *       nodeAccessConfig:
 *         loginUser: root
 * ```
 * 
 * ### Gkeonprem Bare Metal Admin Cluster Full
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const admin_cluster_basic = new gcp.gkeonprem.BareMetalAdminCluster("admin-cluster-basic", {
 *     name: "my-cluster",
 *     location: "us-west1",
 *     description: "test description",
 *     bareMetalVersion: "1.13.4",
 *     annotations: {
 *         env: "test",
 *     },
 *     networkConfig: {
 *         islandModeCidr: {
 *             serviceAddressCidrBlocks: ["172.26.0.0/16"],
 *             podAddressCidrBlocks: ["10.240.0.0/13"],
 *         },
 *     },
 *     nodeConfig: {
 *         maxPodsPerNode: 250,
 *     },
 *     controlPlane: {
 *         controlPlaneNodePoolConfig: {
 *             nodePoolConfig: {
 *                 labels: {},
 *                 operatingSystem: "LINUX",
 *                 nodeConfigs: [
 *                     {
 *                         labels: {},
 *                         nodeIp: "10.200.0.2",
 *                     },
 *                     {
 *                         labels: {},
 *                         nodeIp: "10.200.0.3",
 *                     },
 *                     {
 *                         labels: {},
 *                         nodeIp: "10.200.0.4",
 *                     },
 *                 ],
 *                 taints: [{
 *                     key: "test-key",
 *                     value: "test-value",
 *                     effect: "NO_EXECUTE",
 *                 }],
 *             },
 *         },
 *         apiServerArgs: [{
 *             argument: "test argument",
 *             value: "test value",
 *         }],
 *     },
 *     loadBalancer: {
 *         portConfig: {
 *             controlPlaneLoadBalancerPort: 443,
 *         },
 *         vipConfig: {
 *             controlPlaneVip: "10.200.0.5",
 *         },
 *         manualLbConfig: {
 *             enabled: true,
 *         },
 *     },
 *     storage: {
 *         lvpShareConfig: {
 *             lvpConfig: {
 *                 path: "/mnt/localpv-share",
 *                 storageClass: "local-shared",
 *             },
 *             sharedPathPvCount: 5,
 *         },
 *         lvpNodeMountsConfig: {
 *             path: "/mnt/localpv-disk",
 *             storageClass: "local-disks",
 *         },
 *     },
 *     nodeAccessConfig: {
 *         loginUser: "root",
 *     },
 *     securityConfig: {
 *         authorization: {
 *             adminUsers: [{
 *                 username: "[email protected]",
 *             }],
 *         },
 *     },
 *     maintenanceConfig: {
 *         maintenanceAddressCidrBlocks: [
 *             "10.0.0.1/32",
 *             "10.0.0.2/32",
 *         ],
 *     },
 *     clusterOperations: {
 *         enableApplicationLogs: true,
 *     },
 *     proxy: {
 *         uri: "test proxy uri",
 *         noProxies: ["127.0.0.1"],
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * admin_cluster_basic = gcp.gkeonprem.BareMetalAdminCluster("admin-cluster-basic",
 *     name="my-cluster",
 *     location="us-west1",
 *     description="test description",
 *     bare_metal_version="1.13.4",
 *     annotations={
 *         "env": "test",
 *     },
 *     network_config={
 *         "island_mode_cidr": {
 *             "service_address_cidr_blocks": ["172.26.0.0/16"],
 *             "pod_address_cidr_blocks": ["10.240.0.0/13"],
 *         },
 *     },
 *     node_config={
 *         "max_pods_per_node": 250,
 *     },
 *     control_plane={
 *         "control_plane_node_pool_config": {
 *             "node_pool_config": {
 *                 "labels": {},
 *                 "operating_system": "LINUX",
 *                 "node_configs": [
 *                     {
 *                         "labels": {},
 *                         "node_ip": "10.200.0.2",
 *                     },
 *                     {
 *                         "labels": {},
 *                         "node_ip": "10.200.0.3",
 *                     },
 *                     {
 *                         "labels": {},
 *                         "node_ip": "10.200.0.4",
 *                     },
 *                 ],
 *                 "taints": [{
 *                     "key": "test-key",
 *                     "value": "test-value",
 *                     "effect": "NO_EXECUTE",
 *                 }],
 *             },
 *         },
 *         "api_server_args": [{
 *             "argument": "test argument",
 *             "value": "test value",
 *         }],
 *     },
 *     load_balancer={
 *         "port_config": {
 *             "control_plane_load_balancer_port": 443,
 *         },
 *         "vip_config": {
 *             "control_plane_vip": "10.200.0.5",
 *         },
 *         "manual_lb_config": {
 *             "enabled": True,
 *         },
 *     },
 *     storage={
 *         "lvp_share_config": {
 *             "lvp_config": {
 *                 "path": "/mnt/localpv-share",
 *                 "storage_class": "local-shared",
 *             },
 *             "shared_path_pv_count": 5,
 *         },
 *         "lvp_node_mounts_config": {
 *             "path": "/mnt/localpv-disk",
 *             "storage_class": "local-disks",
 *         },
 *     },
 *     node_access_config={
 *         "login_user": "root",
 *     },
 *     security_config={
 *         "authorization": {
 *             "admin_users": [{
 *                 "username": "[email protected]",
 *             }],
 *         },
 *     },
 *     maintenance_config={
 *         "maintenance_address_cidr_blocks": [
 *             "10.0.0.1/32",
 *             "10.0.0.2/32",
 *         ],
 *     },
 *     cluster_operations={
 *         "enable_application_logs": True,
 *     },
 *     proxy={
 *         "uri": "test proxy uri",
 *         "no_proxies": ["127.0.0.1"],
 *     })
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var admin_cluster_basic = new Gcp.GkeOnPrem.BareMetalAdminCluster("admin-cluster-basic", new()
 *     {
 *         Name = "my-cluster",
 *         Location = "us-west1",
 *         Description = "test description",
 *         BareMetalVersion = "1.13.4",
 *         Annotations =
 *         {
 *             { "env", "test" },
 *         },
 *         NetworkConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNetworkConfigArgs
 *         {
 *             IslandModeCidr = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNetworkConfigIslandModeCidrArgs
 *             {
 *                 ServiceAddressCidrBlocks = new[]
 *                 {
 *                     "172.26.0.0/16",
 *                 },
 *                 PodAddressCidrBlocks = new[]
 *                 {
 *                     "10.240.0.0/13",
 *                 },
 *             },
 *         },
 *         NodeConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNodeConfigArgs
 *         {
 *             MaxPodsPerNode = 250,
 *         },
 *         ControlPlane = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneArgs
 *         {
 *             ControlPlaneNodePoolConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs
 *             {
 *                 NodePoolConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs
 *                 {
 *                     Labels = null,
 *                     OperatingSystem = "LINUX",
 *                     NodeConfigs = new[]
 *                     {
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs
 *                         {
 *                             Labels = null,
 *                             NodeIp = "10.200.0.2",
 *                         },
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs
 *                         {
 *                             Labels = null,
 *                             NodeIp = "10.200.0.3",
 *                         },
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs
 *                         {
 *                             Labels = null,
 *                             NodeIp = "10.200.0.4",
 *                         },
 *                     },
 *                     Taints = new[]
 *                     {
 *                         new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigTaintArgs
 *                         {
 *                             Key = "test-key",
 *                             Value = "test-value",
 *                             Effect = "NO_EXECUTE",
 *                         },
 *                     },
 *                 },
 *             },
 *             ApiServerArgs = new[]
 *             {
 *                 new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterControlPlaneApiServerArgArgs
 *                 {
 *                     Argument = "test argument",
 *                     Value = "test value",
 *                 },
 *             },
 *         },
 *         LoadBalancer = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerArgs
 *         {
 *             PortConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerPortConfigArgs
 *             {
 *                 ControlPlaneLoadBalancerPort = 443,
 *             },
 *             VipConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerVipConfigArgs
 *             {
 *                 ControlPlaneVip = "10.200.0.5",
 *             },
 *             ManualLbConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterLoadBalancerManualLbConfigArgs
 *             {
 *                 Enabled = true,
 *             },
 *         },
 *         Storage = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageArgs
 *         {
 *             LvpShareConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageLvpShareConfigArgs
 *             {
 *                 LvpConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs
 *                 {
 *                     Path = "/mnt/localpv-share",
 *                     StorageClass = "local-shared",
 *                 },
 *                 SharedPathPvCount = 5,
 *             },
 *             LvpNodeMountsConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterStorageLvpNodeMountsConfigArgs
 *             {
 *                 Path = "/mnt/localpv-disk",
 *                 StorageClass = "local-disks",
 *             },
 *         },
 *         NodeAccessConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterNodeAccessConfigArgs
 *         {
 *             LoginUser = "root",
 *         },
 *         SecurityConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterSecurityConfigArgs
 *         {
 *             Authorization = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterSecurityConfigAuthorizationArgs
 *             {
 *                 AdminUsers = new[]
 *                 {
 *                     new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterSecurityConfigAuthorizationAdminUserArgs
 *                     {
 *                         Username = "[email protected]",
 *                     },
 *                 },
 *             },
 *         },
 *         MaintenanceConfig = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterMaintenanceConfigArgs
 *         {
 *             MaintenanceAddressCidrBlocks = new[]
 *             {
 *                 "10.0.0.1/32",
 *                 "10.0.0.2/32",
 *             },
 *         },
 *         ClusterOperations = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterClusterOperationsArgs
 *         {
 *             EnableApplicationLogs = true,
 *         },
 *         Proxy = new Gcp.GkeOnPrem.Inputs.BareMetalAdminClusterProxyArgs
 *         {
 *             Uri = "test proxy uri",
 *             NoProxies = new[]
 *             {
 *                 "127.0.0.1",
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/gkeonprem"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := gkeonprem.NewBareMetalAdminCluster(ctx, "admin-cluster-basic", &gkeonprem.BareMetalAdminClusterArgs{
 * 			Name:             pulumi.String("my-cluster"),
 * 			Location:         pulumi.String("us-west1"),
 * 			Description:      pulumi.String("test description"),
 * 			BareMetalVersion: pulumi.String("1.13.4"),
 * 			Annotations: pulumi.StringMap{
 * 				"env": pulumi.String("test"),
 * 			},
 * 			NetworkConfig: &gkeonprem.BareMetalAdminClusterNetworkConfigArgs{
 * 				IslandModeCidr: &gkeonprem.BareMetalAdminClusterNetworkConfigIslandModeCidrArgs{
 * 					ServiceAddressCidrBlocks: pulumi.StringArray{
 * 						pulumi.String("172.26.0.0/16"),
 * 					},
 * 					PodAddressCidrBlocks: pulumi.StringArray{
 * 						pulumi.String("10.240.0.0/13"),
 * 					},
 * 				},
 * 			},
 * 			NodeConfig: &gkeonprem.BareMetalAdminClusterNodeConfigArgs{
 * 				MaxPodsPerNode: pulumi.Int(250),
 * 			},
 * 			ControlPlane: &gkeonprem.BareMetalAdminClusterControlPlaneArgs{
 * 				ControlPlaneNodePoolConfig: &gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs{
 * 					NodePoolConfig: &gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs{
 * 						Labels:          nil,
 * 						OperatingSystem: pulumi.String("LINUX"),
 * 						NodeConfigs: gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArray{
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs{
 * 								Labels: nil,
 * 								NodeIp: pulumi.String("10.200.0.2"),
 * 							},
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs{
 * 								Labels: nil,
 * 								NodeIp: pulumi.String("10.200.0.3"),
 * 							},
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs{
 * 								Labels: nil,
 * 								NodeIp: pulumi.String("10.200.0.4"),
 * 							},
 * 						},
 * 						Taints: gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigTaintArray{
 * 							&gkeonprem.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigTaintArgs{
 * 								Key:    pulumi.String("test-key"),
 * 								Value:  pulumi.String("test-value"),
 * 								Effect: pulumi.String("NO_EXECUTE"),
 * 							},
 * 						},
 * 					},
 * 				},
 * 				ApiServerArgs: gkeonprem.BareMetalAdminClusterControlPlaneApiServerArgArray{
 * 					&gkeonprem.BareMetalAdminClusterControlPlaneApiServerArgArgs{
 * 						Argument: pulumi.String("test argument"),
 * 						Value:    pulumi.String("test value"),
 * 					},
 * 				},
 * 			},
 * 			LoadBalancer: &gkeonprem.BareMetalAdminClusterLoadBalancerArgs{
 * 				PortConfig: &gkeonprem.BareMetalAdminClusterLoadBalancerPortConfigArgs{
 * 					ControlPlaneLoadBalancerPort: pulumi.Int(443),
 * 				},
 * 				VipConfig: &gkeonprem.BareMetalAdminClusterLoadBalancerVipConfigArgs{
 * 					ControlPlaneVip: pulumi.String("10.200.0.5"),
 * 				},
 * 				ManualLbConfig: &gkeonprem.BareMetalAdminClusterLoadBalancerManualLbConfigArgs{
 * 					Enabled: pulumi.Bool(true),
 * 				},
 * 			},
 * 			Storage: &gkeonprem.BareMetalAdminClusterStorageArgs{
 * 				LvpShareConfig: &gkeonprem.BareMetalAdminClusterStorageLvpShareConfigArgs{
 * 					LvpConfig: &gkeonprem.BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs{
 * 						Path:         pulumi.String("/mnt/localpv-share"),
 * 						StorageClass: pulumi.String("local-shared"),
 * 					},
 * 					SharedPathPvCount: pulumi.Int(5),
 * 				},
 * 				LvpNodeMountsConfig: &gkeonprem.BareMetalAdminClusterStorageLvpNodeMountsConfigArgs{
 * 					Path:         pulumi.String("/mnt/localpv-disk"),
 * 					StorageClass: pulumi.String("local-disks"),
 * 				},
 * 			},
 * 			NodeAccessConfig: &gkeonprem.BareMetalAdminClusterNodeAccessConfigArgs{
 * 				LoginUser: pulumi.String("root"),
 * 			},
 * 			SecurityConfig: &gkeonprem.BareMetalAdminClusterSecurityConfigArgs{
 * 				Authorization: &gkeonprem.BareMetalAdminClusterSecurityConfigAuthorizationArgs{
 * 					AdminUsers: gkeonprem.BareMetalAdminClusterSecurityConfigAuthorizationAdminUserArray{
 * 						&gkeonprem.BareMetalAdminClusterSecurityConfigAuthorizationAdminUserArgs{
 * 							Username: pulumi.String("[email protected]"),
 * 						},
 * 					},
 * 				},
 * 			},
 * 			MaintenanceConfig: &gkeonprem.BareMetalAdminClusterMaintenanceConfigArgs{
 * 				MaintenanceAddressCidrBlocks: pulumi.StringArray{
 * 					pulumi.String("10.0.0.1/32"),
 * 					pulumi.String("10.0.0.2/32"),
 * 				},
 * 			},
 * 			ClusterOperations: &gkeonprem.BareMetalAdminClusterClusterOperationsArgs{
 * 				EnableApplicationLogs: pulumi.Bool(true),
 * 			},
 * 			Proxy: &gkeonprem.BareMetalAdminClusterProxyArgs{
 * 				Uri: pulumi.String("test proxy uri"),
 * 				NoProxies: pulumi.StringArray{
 * 					pulumi.String("127.0.0.1"),
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.gkeonprem.BareMetalAdminCluster;
 * import com.pulumi.gcp.gkeonprem.BareMetalAdminClusterArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNetworkConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNetworkConfigIslandModeCidrArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNodeConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterControlPlaneArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerPortConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerVipConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterLoadBalancerManualLbConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageLvpShareConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterStorageLvpNodeMountsConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterNodeAccessConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterSecurityConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterSecurityConfigAuthorizationArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterMaintenanceConfigArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterClusterOperationsArgs;
 * import com.pulumi.gcp.gkeonprem.inputs.BareMetalAdminClusterProxyArgs;
 * 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 admin_cluster_basic = new BareMetalAdminCluster("admin-cluster-basic", BareMetalAdminClusterArgs.builder()
 *             .name("my-cluster")
 *             .location("us-west1")
 *             .description("test description")
 *             .bareMetalVersion("1.13.4")
 *             .annotations(Map.of("env", "test"))
 *             .networkConfig(BareMetalAdminClusterNetworkConfigArgs.builder()
 *                 .islandModeCidr(BareMetalAdminClusterNetworkConfigIslandModeCidrArgs.builder()
 *                     .serviceAddressCidrBlocks("172.26.0.0/16")
 *                     .podAddressCidrBlocks("10.240.0.0/13")
 *                     .build())
 *                 .build())
 *             .nodeConfig(BareMetalAdminClusterNodeConfigArgs.builder()
 *                 .maxPodsPerNode(250)
 *                 .build())
 *             .controlPlane(BareMetalAdminClusterControlPlaneArgs.builder()
 *                 .controlPlaneNodePoolConfig(BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigArgs.builder()
 *                     .nodePoolConfig(BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigArgs.builder()
 *                         .labels()
 *                         .operatingSystem("LINUX")
 *                         .nodeConfigs(
 *                             BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs.builder()
 *                                 .labels()
 *                                 .nodeIp("10.200.0.2")
 *                                 .build(),
 *                             BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs.builder()
 *                                 .labels()
 *                                 .nodeIp("10.200.0.3")
 *                                 .build(),
 *                             BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigNodeConfigArgs.builder()
 *                                 .labels()
 *                                 .nodeIp("10.200.0.4")
 *                                 .build())
 *                         .taints(BareMetalAdminClusterControlPlaneControlPlaneNodePoolConfigNodePoolConfigTaintArgs.builder()
 *                             .key("test-key")
 *                             .value("test-value")
 *                             .effect("NO_EXECUTE")
 *                             .build())
 *                         .build())
 *                     .build())
 *                 .apiServerArgs(BareMetalAdminClusterControlPlaneApiServerArgArgs.builder()
 *                     .argument("test argument")
 *                     .value("test value")
 *                     .build())
 *                 .build())
 *             .loadBalancer(BareMetalAdminClusterLoadBalancerArgs.builder()
 *                 .portConfig(BareMetalAdminClusterLoadBalancerPortConfigArgs.builder()
 *                     .controlPlaneLoadBalancerPort(443)
 *                     .build())
 *                 .vipConfig(BareMetalAdminClusterLoadBalancerVipConfigArgs.builder()
 *                     .controlPlaneVip("10.200.0.5")
 *                     .build())
 *                 .manualLbConfig(BareMetalAdminClusterLoadBalancerManualLbConfigArgs.builder()
 *                     .enabled(true)
 *                     .build())
 *                 .build())
 *             .storage(BareMetalAdminClusterStorageArgs.builder()
 *                 .lvpShareConfig(BareMetalAdminClusterStorageLvpShareConfigArgs.builder()
 *                     .lvpConfig(BareMetalAdminClusterStorageLvpShareConfigLvpConfigArgs.builder()
 *                         .path("/mnt/localpv-share")
 *                         .storageClass("local-shared")
 *                         .build())
 *                     .sharedPathPvCount(5)
 *                     .build())
 *                 .lvpNodeMountsConfig(BareMetalAdminClusterStorageLvpNodeMountsConfigArgs.builder()
 *                     .path("/mnt/localpv-disk")
 *                     .storageClass("local-disks")
 *                     .build())
 *                 .build())
 *             .nodeAccessConfig(BareMetalAdminClusterNodeAccessConfigArgs.builder()
 *                 .loginUser("root")
 *                 .build())
 *             .securityConfig(BareMetalAdminClusterSecurityConfigArgs.builder()
 *                 .authorization(BareMetalAdminClusterSecurityConfigAuthorizationArgs.builder()
 *                     .adminUsers(BareMetalAdminClusterSecurityConfigAuthorizationAdminUserArgs.builder()
 *                         .username("[email protected]")
 *                         .build())
 *                     .build())
 *                 .build())
 *             .maintenanceConfig(BareMetalAdminClusterMaintenanceConfigArgs.builder()
 *                 .maintenanceAddressCidrBlocks(
 *                     "10.0.0.1/32",
 *                     "10.0.0.2/32")
 *                 .build())
 *             .clusterOperations(BareMetalAdminClusterClusterOperationsArgs.builder()
 *                 .enableApplicationLogs(true)
 *                 .build())
 *             .proxy(BareMetalAdminClusterProxyArgs.builder()
 *                 .uri("test proxy uri")
 *                 .noProxies("127.0.0.1")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   admin-cluster-basic:
 *     type: gcp:gkeonprem:BareMetalAdminCluster
 *     properties:
 *       name: my-cluster
 *       location: us-west1
 *       description: test description
 *       bareMetalVersion: 1.13.4
 *       annotations:
 *         env: test
 *       networkConfig:
 *         islandModeCidr:
 *           serviceAddressCidrBlocks:
 *             - 172.26.0.0/16
 *           podAddressCidrBlocks:
 *             - 10.240.0.0/13
 *       nodeConfig:
 *         maxPodsPerNode: 250
 *       controlPlane:
 *         controlPlaneNodePoolConfig:
 *           nodePoolConfig:
 *             labels: {}
 *             operatingSystem: LINUX
 *             nodeConfigs:
 *               - labels: {}
 *                 nodeIp: 10.200.0.2
 *               - labels: {}
 *                 nodeIp: 10.200.0.3
 *               - labels: {}
 *                 nodeIp: 10.200.0.4
 *             taints:
 *               - key: test-key
 *                 value: test-value
 *                 effect: NO_EXECUTE
 *         apiServerArgs:
 *           - argument: test argument
 *             value: test value
 *       loadBalancer:
 *         portConfig:
 *           controlPlaneLoadBalancerPort: 443
 *         vipConfig:
 *           controlPlaneVip: 10.200.0.5
 *         manualLbConfig:
 *           enabled: true
 *       storage:
 *         lvpShareConfig:
 *           lvpConfig:
 *             path: /mnt/localpv-share
 *             storageClass: local-shared
 *           sharedPathPvCount: 5
 *         lvpNodeMountsConfig:
 *           path: /mnt/localpv-disk
 *           storageClass: local-disks
 *       nodeAccessConfig:
 *         loginUser: root
 *       securityConfig:
 *         authorization:
 *           adminUsers:
 *             - username: [email protected]
 *       maintenanceConfig:
 *         maintenanceAddressCidrBlocks:
 *           - 10.0.0.1/32
 *           - 10.0.0.2/32
 *       clusterOperations:
 *         enableApplicationLogs: true
 *       proxy:
 *         uri: test proxy uri
 *         noProxies:
 *           - 127.0.0.1
 * ```
 * 
 * ## Import
 * BareMetalAdminCluster can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{location}}/bareMetalAdminClusters/{{name}}`
 * * `{{project}}/{{location}}/{{name}}`
 * * `{{location}}/{{name}}`
 * When using the `pulumi import` command, BareMetalAdminCluster can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:gkeonprem/bareMetalAdminCluster:BareMetalAdminCluster default projects/{{project}}/locations/{{location}}/bareMetalAdminClusters/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:gkeonprem/bareMetalAdminCluster:BareMetalAdminCluster default {{project}}/{{location}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:gkeonprem/bareMetalAdminCluster:BareMetalAdminCluster default {{location}}/{{name}}
 * ```
 */
public class BareMetalAdminCluster internal constructor(
    override val javaResource: com.pulumi.gcp.gkeonprem.BareMetalAdminCluster,
) : KotlinCustomResource(javaResource, BareMetalAdminClusterMapper) {
    /**
     * Annotations on the Bare Metal Admin Cluster.
     * This field has the same restrictions as Kubernetes annotations.
     * The total size of all keys and values combined is limited to 256k.
     * Key can have 2 segments: prefix (optional) and name (required),
     * separated by a slash (/).
     * Prefix must be a DNS subdomain.
     * Name must be 63 characters or less, begin and end with alphanumerics,
     * with dashes (-), underscores (_), dots (.), and alphanumerics between.
     * **Note**: This field is non-authoritative, and will only manage the annotations present in your configuration.
     * Please refer to the field `effective_annotations` for all of the annotations present on the resource.
     */
    public val annotations: Output>?
        get() = javaResource.annotations().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.map({ args0 ->
                    args0.key.to(args0.value)
                }).toMap()
            }).orElse(null)
        })

    /**
     * A human readable description of this Bare Metal Admin Cluster.
     */
    public val bareMetalVersion: Output?
        get() = javaResource.bareMetalVersion().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    /**
     * Specifies the Admin Cluster's observability infrastructure.
     * Structure is documented below.
     */
    public val clusterOperations: Output?
        get() = javaResource.clusterOperations().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> bareMetalAdminClusterClusterOperationsToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * Specifies the control plane configuration.
     * Structure is documented below.
     */
    public val controlPlane: Output?
        get() = javaResource.controlPlane().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterControlPlaneToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * The time the cluster was created, in RFC3339 text format.
     */
    public val createTime: Output
        get() = javaResource.createTime().applyValue({ args0 -> args0 })

    /**
     * The time the cluster was deleted, in RFC3339 text format.
     */
    public val deleteTime: Output
        get() = javaResource.deleteTime().applyValue({ args0 -> args0 })

    /**
     * A human readable description of this Bare Metal Admin Cluster.
     */
    public val description: Output?
        get() = javaResource.description().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    public val effectiveAnnotations: Output>
        get() = javaResource.effectiveAnnotations().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.key.to(args0.value)
            }).toMap()
        })

    /**
     * The IP address name of Bare Metal Admin Cluster's API server.
     */
    public val endpoint: Output
        get() = javaResource.endpoint().applyValue({ args0 -> args0 })

    /**
     * This checksum is computed by the server based on the value of other
     * fields, and may be sent on update and delete requests to ensure the
     * client has an up-to-date value before proceeding.
     * Allows clients to perform consistent read-modify-writes
     * through optimistic concurrency control.
     */
    public val etag: Output
        get() = javaResource.etag().applyValue({ args0 -> args0 })

    /**
     * Fleet related configuration.
     * Fleets are a Google Cloud concept for logically organizing clusters,
     * letting you use and manage multi-cluster capabilities and apply
     * consistent policies across your systems.
     * See [Anthos Fleets](https://cloud.google.com/anthos/multicluster-management/fleets) for
     * more details on Anthos multi-cluster capabilities using Fleets.
     * Structure is documented below.
     */
    public val fleets: Output>
        get() = javaResource.fleets().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterFleetToKotlin(args0)
                })
            })
        })

    /**
     * Specifies the load balancer configuration.
     * Structure is documented below.
     */
    public val loadBalancer: Output?
        get() = javaResource.loadBalancer().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterLoadBalancerToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * The object name of the Bare Metal Admin Cluster custom resource on the
     * associated admin cluster. This field is used to support conflicting
     * names when enrolling existing clusters to the API. When used as a part of
     * cluster enrollment, this field will differ from the ID in the resource
     * name. For new clusters, this field will match the user provided cluster ID
     * and be visible in the last component of the resource name. It is not
     * modifiable.
     * All users should use this name to access their cluster using gkectl or
     * kubectl and should expect to see the local name when viewing admin
     * cluster controller logs.
     */
    public val localName: Output
        get() = javaResource.localName().applyValue({ args0 -> args0 })

    /**
     * The location of the resource.
     * - - -
     */
    public val location: Output
        get() = javaResource.location().applyValue({ args0 -> args0 })

    /**
     * Specifies the workload node configurations.
     * Structure is documented below.
     */
    public val maintenanceConfig: Output?
        get() = javaResource.maintenanceConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> bareMetalAdminClusterMaintenanceConfigToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * The bare metal admin cluster name.
     */
    public val name: Output
        get() = javaResource.name().applyValue({ args0 -> args0 })

    /**
     * Network configuration.
     * Structure is documented below.
     */
    public val networkConfig: Output?
        get() = javaResource.networkConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> bareMetalAdminClusterNetworkConfigToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * Specifies the node access related settings for the bare metal user cluster.
     * Structure is documented below.
     */
    public val nodeAccessConfig: Output?
        get() = javaResource.nodeAccessConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> bareMetalAdminClusterNodeAccessConfigToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * Specifies the workload node configurations.
     * Structure is documented below.
     */
    public val nodeConfig: Output?
        get() = javaResource.nodeConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterNodeConfigToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    public val project: Output
        get() = javaResource.project().applyValue({ args0 -> args0 })

    /**
     * Specifies the cluster proxy configuration.
     * Structure is documented below.
     */
    public val proxy: Output?
        get() = javaResource.proxy().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterProxyToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * If set, there are currently changes in flight to the Bare Metal Admin Cluster.
     */
    public val reconciling: Output
        get() = javaResource.reconciling().applyValue({ args0 -> args0 })

    /**
     * Specifies the security related settings for the Bare Metal User Cluster.
     * Structure is documented below.
     */
    public val securityConfig: Output?
        get() = javaResource.securityConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> bareMetalAdminClusterSecurityConfigToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * (Output)
     * The lifecycle state of the condition.
     */
    public val state: Output
        get() = javaResource.state().applyValue({ args0 -> args0 })

    /**
     * (Output)
     * Specifies the detailed validation check status
     * Structure is documented below.
     */
    public val statuses: Output>
        get() = javaResource.statuses().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterStatusToKotlin(args0)
                })
            })
        })

    /**
     * Specifies the cluster storage configuration.
     * Structure is documented below.
     */
    public val storage: Output?
        get() = javaResource.storage().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    bareMetalAdminClusterStorageToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * The unique identifier of the Bare Metal Admin Cluster.
     */
    public val uid: Output
        get() = javaResource.uid().applyValue({ args0 -> args0 })

    /**
     * The time the cluster was last updated, in RFC3339 text format.
     */
    public val updateTime: Output
        get() = javaResource.updateTime().applyValue({ args0 -> args0 })

    /**
     * Specifies the security related settings for the Bare Metal Admin Cluster.
     * Structure is documented below.
     */
    public val validationChecks: Output>
        get() = javaResource.validationChecks().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> bareMetalAdminClusterValidationCheckToKotlin(args0) })
            })
        })
}

public object BareMetalAdminClusterMapper : ResourceMapper {
    override fun supportsMappingOfType(javaResource: Resource): Boolean =
        com.pulumi.gcp.gkeonprem.BareMetalAdminCluster::class == javaResource::class

    override fun map(javaResource: Resource): BareMetalAdminCluster =
        BareMetalAdminCluster(javaResource as com.pulumi.gcp.gkeonprem.BareMetalAdminCluster)
}

/**
 * @see [BareMetalAdminCluster].
 * @param name The _unique_ name of the resulting resource.
 * @param block Builder for [BareMetalAdminCluster].
 */
public suspend fun bareMetalAdminCluster(
    name: String,
    block: suspend BareMetalAdminClusterResourceBuilder.() -> Unit,
): BareMetalAdminCluster {
    val builder = BareMetalAdminClusterResourceBuilder()
    builder.name(name)
    block(builder)
    return builder.build()
}

/**
 * @see [BareMetalAdminCluster].
 * @param name The _unique_ name of the resulting resource.
 */
public fun bareMetalAdminCluster(name: String): BareMetalAdminCluster {
    val builder = BareMetalAdminClusterResourceBuilder()
    builder.name(name)
    return builder.build()
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy