pulumi-gcp-kotlin/com.pulumi.gcp.gkeonprem.kotlin/VmwareAdminCluster

VmwareAdminCluster

class VmwareAdminCluster : KotlinCustomResource

Example Usage

Gkeonprem Vmware Admin Cluster Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const admin_cluster_basic = new gcp.gkeonprem.VmwareAdminCluster("admin-cluster-basic", {
    name: "basic",
    location: "us-west1",
    description: "test admin cluster",
    bootstrapClusterMembership: "projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
    onPremVersion: "1.31.0-gke.35",
    imageType: "ubuntu_containerd",
    vcenter: {
        resourcePool: "test resource pool",
        datastore: "test data store",
        datacenter: "test data center",
        cluster: "test cluster",
        folder: "test folder",
        caCertData: "test ca cert data",
        address: "10.0.0.1",
        dataDisk: "test data disk",
    },
    networkConfig: {
        serviceAddressCidrBlocks: ["10.96.0.0/12"],
        podAddressCidrBlocks: ["192.168.0.0/16"],
        dhcpIpConfig: {
            enabled: true,
        },
    },
    controlPlaneNode: {
        cpus: 4,
        memory: 8192,
    },
    loadBalancer: {
        vipConfig: {
            controlPlaneVip: "10.251.133.5",
            addonsVip: "10.251.135.19",
        },
        f5Config: {
            address: "10.251.135.22",
            partition: "test-parition",
            snatPool: "test-snat-pool",
        },
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
admin_cluster_basic = gcp.gkeonprem.VmwareAdminCluster("admin-cluster-basic",
    name="basic",
    location="us-west1",
    description="test admin cluster",
    bootstrap_cluster_membership="projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
    on_prem_version="1.31.0-gke.35",
    image_type="ubuntu_containerd",
    vcenter={
        "resource_pool": "test resource pool",
        "datastore": "test data store",
        "datacenter": "test data center",
        "cluster": "test cluster",
        "folder": "test folder",
        "ca_cert_data": "test ca cert data",
        "address": "10.0.0.1",
        "data_disk": "test data disk",
    },
    network_config={
        "service_address_cidr_blocks": ["10.96.0.0/12"],
        "pod_address_cidr_blocks": ["192.168.0.0/16"],
        "dhcp_ip_config": {
            "enabled": True,
        },
    },
    control_plane_node={
        "cpus": 4,
        "memory": 8192,
    },
    load_balancer={
        "vip_config": {
            "control_plane_vip": "10.251.133.5",
            "addons_vip": "10.251.135.19",
        },
        "f5_config": {
            "address": "10.251.135.22",
            "partition": "test-parition",
            "snat_pool": "test-snat-pool",
        },
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var admin_cluster_basic = new Gcp.GkeOnPrem.VmwareAdminCluster("admin-cluster-basic", new()
    {
        Name = "basic",
        Location = "us-west1",
        Description = "test admin cluster",
        BootstrapClusterMembership = "projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
        OnPremVersion = "1.31.0-gke.35",
        ImageType = "ubuntu_containerd",
        Vcenter = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterVcenterArgs
        {
            ResourcePool = "test resource pool",
            Datastore = "test data store",
            Datacenter = "test data center",
            Cluster = "test cluster",
            Folder = "test folder",
            CaCertData = "test ca cert data",
            Address = "10.0.0.1",
            DataDisk = "test data disk",
        },
        NetworkConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigArgs
        {
            ServiceAddressCidrBlocks = new[]
            {
                "10.96.0.0/12",
            },
            PodAddressCidrBlocks = new[]
            {
                "192.168.0.0/16",
            },
            DhcpIpConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigDhcpIpConfigArgs
            {
                Enabled = true,
            },
        },
        ControlPlaneNode = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterControlPlaneNodeArgs
        {
            Cpus = 4,
            Memory = 8192,
        },
        LoadBalancer = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerArgs
        {
            VipConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerVipConfigArgs
            {
                ControlPlaneVip = "10.251.133.5",
                AddonsVip = "10.251.135.19",
            },
            F5Config = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerF5ConfigArgs
            {
                Address = "10.251.135.22",
                Partition = "test-parition",
                SnatPool = "test-snat-pool",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/gkeonprem"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gkeonprem.NewVmwareAdminCluster(ctx, "admin-cluster-basic", &gkeonprem.VmwareAdminClusterArgs{
			Name:                       pulumi.String("basic"),
			Location:                   pulumi.String("us-west1"),
			Description:                pulumi.String("test admin cluster"),
			BootstrapClusterMembership: pulumi.String("projects/870316890899/locations/global/memberships/gkeonprem-terraform-test"),
			OnPremVersion:              pulumi.String("1.31.0-gke.35"),
			ImageType:                  pulumi.String("ubuntu_containerd"),
			Vcenter: &gkeonprem.VmwareAdminClusterVcenterArgs{
				ResourcePool: pulumi.String("test resource pool"),
				Datastore:    pulumi.String("test data store"),
				Datacenter:   pulumi.String("test data center"),
				Cluster:      pulumi.String("test cluster"),
				Folder:       pulumi.String("test folder"),
				CaCertData:   pulumi.String("test ca cert data"),
				Address:      pulumi.String("10.0.0.1"),
				DataDisk:     pulumi.String("test data disk"),
			},
			NetworkConfig: &gkeonprem.VmwareAdminClusterNetworkConfigArgs{
				ServiceAddressCidrBlocks: pulumi.StringArray{
					pulumi.String("10.96.0.0/12"),
				},
				PodAddressCidrBlocks: pulumi.StringArray{
					pulumi.String("192.168.0.0/16"),
				},
				DhcpIpConfig: &gkeonprem.VmwareAdminClusterNetworkConfigDhcpIpConfigArgs{
					Enabled: pulumi.Bool(true),
				},
			},
			ControlPlaneNode: &gkeonprem.VmwareAdminClusterControlPlaneNodeArgs{
				Cpus:   pulumi.Int(4),
				Memory: pulumi.Int(8192),
			},
			LoadBalancer: &gkeonprem.VmwareAdminClusterLoadBalancerArgs{
				VipConfig: &gkeonprem.VmwareAdminClusterLoadBalancerVipConfigArgs{
					ControlPlaneVip: pulumi.String("10.251.133.5"),
					AddonsVip:       pulumi.String("10.251.135.19"),
				},
				F5Config: &gkeonprem.VmwareAdminClusterLoadBalancerF5ConfigArgs{
					Address:   pulumi.String("10.251.135.22"),
					Partition: pulumi.String("test-parition"),
					SnatPool:  pulumi.String("test-snat-pool"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.gkeonprem.VmwareAdminCluster;
import com.pulumi.gcp.gkeonprem.VmwareAdminClusterArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterVcenterArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigDhcpIpConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterControlPlaneNodeArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerVipConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerF5ConfigArgs;
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 VmwareAdminCluster("admin-cluster-basic", VmwareAdminClusterArgs.builder()
            .name("basic")
            .location("us-west1")
            .description("test admin cluster")
            .bootstrapClusterMembership("projects/870316890899/locations/global/memberships/gkeonprem-terraform-test")
            .onPremVersion("1.31.0-gke.35")
            .imageType("ubuntu_containerd")
            .vcenter(VmwareAdminClusterVcenterArgs.builder()
                .resourcePool("test resource pool")
                .datastore("test data store")
                .datacenter("test data center")
                .cluster("test cluster")
                .folder("test folder")
                .caCertData("test ca cert data")
                .address("10.0.0.1")
                .dataDisk("test data disk")
                .build())
            .networkConfig(VmwareAdminClusterNetworkConfigArgs.builder()
                .serviceAddressCidrBlocks("10.96.0.0/12")
                .podAddressCidrBlocks("192.168.0.0/16")
                .dhcpIpConfig(VmwareAdminClusterNetworkConfigDhcpIpConfigArgs.builder()
                    .enabled(true)
                    .build())
                .build())
            .controlPlaneNode(VmwareAdminClusterControlPlaneNodeArgs.builder()
                .cpus(4)
                .memory(8192)
                .build())
            .loadBalancer(VmwareAdminClusterLoadBalancerArgs.builder()
                .vipConfig(VmwareAdminClusterLoadBalancerVipConfigArgs.builder()
                    .controlPlaneVip("10.251.133.5")
                    .addonsVip("10.251.135.19")
                    .build())
                .f5Config(VmwareAdminClusterLoadBalancerF5ConfigArgs.builder()
                    .address("10.251.135.22")
                    .partition("test-parition")
                    .snatPool("test-snat-pool")
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  admin-cluster-basic:
    type: gcp:gkeonprem:VmwareAdminCluster
    properties:
      name: basic
      location: us-west1
      description: test admin cluster
      bootstrapClusterMembership: projects/870316890899/locations/global/memberships/gkeonprem-terraform-test
      onPremVersion: 1.31.0-gke.35
      imageType: ubuntu_containerd
      vcenter:
        resourcePool: test resource pool
        datastore: test data store
        datacenter: test data center
        cluster: test cluster
        folder: test folder
        caCertData: test ca cert data
        address: 10.0.0.1
        dataDisk: test data disk
      networkConfig:
        serviceAddressCidrBlocks:
          - 10.96.0.0/12
        podAddressCidrBlocks:
          - 192.168.0.0/16
        dhcpIpConfig:
          enabled: true
      controlPlaneNode:
        cpus: 4
        memory: 8192
      loadBalancer:
        vipConfig:
          controlPlaneVip: 10.251.133.5
          addonsVip: 10.251.135.19
        f5Config:
          address: 10.251.135.22
          partition: test-parition
          snatPool: test-snat-pool
Content copied to clipboard

Gkeonprem Vmware Admin Cluster Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const admin_cluster_full = new gcp.gkeonprem.VmwareAdminCluster("admin-cluster-full", {
    name: "full",
    location: "us-west1",
    description: "test admin cluster",
    bootstrapClusterMembership: "projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
    onPremVersion: "1.31.0-gke.35",
    imageType: "ubuntu_containerd",
    annotations: {},
    vcenter: {
        resourcePool: "test resource pool",
        datastore: "test data store",
        datacenter: "test data center",
        cluster: "test cluster",
        folder: "test folder",
        caCertData: "test ca cert data",
        address: "10.0.0.1",
        dataDisk: "test data disk",
        storagePolicyName: "storage_policy_name",
    },
    networkConfig: {
        serviceAddressCidrBlocks: ["10.96.0.0/12"],
        podAddressCidrBlocks: ["192.168.0.0/16"],
        haControlPlaneConfig: {
            controlPlaneIpBlock: {
                gateway: "10.0.0.3",
                ips: [{
                    hostname: "hostname",
                    ip: "10.0.0.4",
                }],
                netmask: "10.0.0.3/32",
            },
        },
        hostConfig: {
            dnsServers: ["10.254.41.1"],
            ntpServers: ["216.239.35.8"],
            dnsSearchDomains: ["test-domain"],
        },
        staticIpConfig: {
            ipBlocks: [{
                gateway: "10.0.0.1",
                ips: [{
                    hostname: "hostname",
                    ip: "10.0.0.2",
                }],
                netmask: "10.0.0.3/32",
            }],
        },
        vcenterNetwork: "test-vcenter-network",
    },
    controlPlaneNode: {
        cpus: 4,
        memory: 8192,
        replicas: 3,
    },
    loadBalancer: {
        vipConfig: {
            controlPlaneVip: "10.251.133.5",
            addonsVip: "10.251.135.19",
        },
        manualLbConfig: {
            addonsNodePort: 30005,
            controlPlaneNodePort: 30006,
            ingressHttpNodePort: 30007,
            ingressHttpsNodePort: 30008,
            konnectivityServerNodePort: 30009,
        },
    },
    addonNode: {
        autoResizeConfig: {
            enabled: true,
        },
    },
    antiAffinityGroups: {
        aagConfigDisabled: true,
    },
    authorization: {
        viewerUsers: [{
            username: "user1@gmail.com",
        }],
    },
    autoRepairConfig: {
        enabled: true,
    },
    platformConfig: {
        requiredPlatformVersion: "1.31.0",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
admin_cluster_full = gcp.gkeonprem.VmwareAdminCluster("admin-cluster-full",
    name="full",
    location="us-west1",
    description="test admin cluster",
    bootstrap_cluster_membership="projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
    on_prem_version="1.31.0-gke.35",
    image_type="ubuntu_containerd",
    annotations={},
    vcenter={
        "resource_pool": "test resource pool",
        "datastore": "test data store",
        "datacenter": "test data center",
        "cluster": "test cluster",
        "folder": "test folder",
        "ca_cert_data": "test ca cert data",
        "address": "10.0.0.1",
        "data_disk": "test data disk",
        "storage_policy_name": "storage_policy_name",
    },
    network_config={
        "service_address_cidr_blocks": ["10.96.0.0/12"],
        "pod_address_cidr_blocks": ["192.168.0.0/16"],
        "ha_control_plane_config": {
            "control_plane_ip_block": {
                "gateway": "10.0.0.3",
                "ips": [{
                    "hostname": "hostname",
                    "ip": "10.0.0.4",
                }],
                "netmask": "10.0.0.3/32",
            },
        },
        "host_config": {
            "dns_servers": ["10.254.41.1"],
            "ntp_servers": ["216.239.35.8"],
            "dns_search_domains": ["test-domain"],
        },
        "static_ip_config": {
            "ip_blocks": [{
                "gateway": "10.0.0.1",
                "ips": [{
                    "hostname": "hostname",
                    "ip": "10.0.0.2",
                }],
                "netmask": "10.0.0.3/32",
            }],
        },
        "vcenter_network": "test-vcenter-network",
    },
    control_plane_node={
        "cpus": 4,
        "memory": 8192,
        "replicas": 3,
    },
    load_balancer={
        "vip_config": {
            "control_plane_vip": "10.251.133.5",
            "addons_vip": "10.251.135.19",
        },
        "manual_lb_config": {
            "addons_node_port": 30005,
            "control_plane_node_port": 30006,
            "ingress_http_node_port": 30007,
            "ingress_https_node_port": 30008,
            "konnectivity_server_node_port": 30009,
        },
    },
    addon_node={
        "auto_resize_config": {
            "enabled": True,
        },
    },
    anti_affinity_groups={
        "aag_config_disabled": True,
    },
    authorization={
        "viewer_users": [{
            "username": "user1@gmail.com",
        }],
    },
    auto_repair_config={
        "enabled": True,
    },
    platform_config={
        "required_platform_version": "1.31.0",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var admin_cluster_full = new Gcp.GkeOnPrem.VmwareAdminCluster("admin-cluster-full", new()
    {
        Name = "full",
        Location = "us-west1",
        Description = "test admin cluster",
        BootstrapClusterMembership = "projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
        OnPremVersion = "1.31.0-gke.35",
        ImageType = "ubuntu_containerd",
        Annotations = null,
        Vcenter = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterVcenterArgs
        {
            ResourcePool = "test resource pool",
            Datastore = "test data store",
            Datacenter = "test data center",
            Cluster = "test cluster",
            Folder = "test folder",
            CaCertData = "test ca cert data",
            Address = "10.0.0.1",
            DataDisk = "test data disk",
            StoragePolicyName = "storage_policy_name",
        },
        NetworkConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigArgs
        {
            ServiceAddressCidrBlocks = new[]
            {
                "10.96.0.0/12",
            },
            PodAddressCidrBlocks = new[]
            {
                "192.168.0.0/16",
            },
            HaControlPlaneConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigHaControlPlaneConfigArgs
            {
                ControlPlaneIpBlock = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockArgs
                {
                    Gateway = "10.0.0.3",
                    Ips = new[]
                    {
                        new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockIpArgs
                        {
                            Hostname = "hostname",
                            Ip = "10.0.0.4",
                        },
                    },
                    Netmask = "10.0.0.3/32",
                },
            },
            HostConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigHostConfigArgs
            {
                DnsServers = new[]
                {
                    "10.254.41.1",
                },
                NtpServers = new[]
                {
                    "216.239.35.8",
                },
                DnsSearchDomains = new[]
                {
                    "test-domain",
                },
            },
            StaticIpConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigStaticIpConfigArgs
            {
                IpBlocks = new[]
                {
                    new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockArgs
                    {
                        Gateway = "10.0.0.1",
                        Ips = new[]
                        {
                            new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockIpArgs
                            {
                                Hostname = "hostname",
                                Ip = "10.0.0.2",
                            },
                        },
                        Netmask = "10.0.0.3/32",
                    },
                },
            },
            VcenterNetwork = "test-vcenter-network",
        },
        ControlPlaneNode = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterControlPlaneNodeArgs
        {
            Cpus = 4,
            Memory = 8192,
            Replicas = 3,
        },
        LoadBalancer = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerArgs
        {
            VipConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerVipConfigArgs
            {
                ControlPlaneVip = "10.251.133.5",
                AddonsVip = "10.251.135.19",
            },
            ManualLbConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerManualLbConfigArgs
            {
                AddonsNodePort = 30005,
                ControlPlaneNodePort = 30006,
                IngressHttpNodePort = 30007,
                IngressHttpsNodePort = 30008,
                KonnectivityServerNodePort = 30009,
            },
        },
        AddonNode = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterAddonNodeArgs
        {
            AutoResizeConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterAddonNodeAutoResizeConfigArgs
            {
                Enabled = true,
            },
        },
        AntiAffinityGroups = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterAntiAffinityGroupsArgs
        {
            AagConfigDisabled = true,
        },
        Authorization = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterAuthorizationArgs
        {
            ViewerUsers = new[]
            {
                new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterAuthorizationViewerUserArgs
                {
                    Username = "user1@gmail.com",
                },
            },
        },
        AutoRepairConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterAutoRepairConfigArgs
        {
            Enabled = true,
        },
        PlatformConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterPlatformConfigArgs
        {
            RequiredPlatformVersion = "1.31.0",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/gkeonprem"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gkeonprem.NewVmwareAdminCluster(ctx, "admin-cluster-full", &gkeonprem.VmwareAdminClusterArgs{
			Name:                       pulumi.String("full"),
			Location:                   pulumi.String("us-west1"),
			Description:                pulumi.String("test admin cluster"),
			BootstrapClusterMembership: pulumi.String("projects/870316890899/locations/global/memberships/gkeonprem-terraform-test"),
			OnPremVersion:              pulumi.String("1.31.0-gke.35"),
			ImageType:                  pulumi.String("ubuntu_containerd"),
			Annotations:                pulumi.StringMap{},
			Vcenter: &gkeonprem.VmwareAdminClusterVcenterArgs{
				ResourcePool:      pulumi.String("test resource pool"),
				Datastore:         pulumi.String("test data store"),
				Datacenter:        pulumi.String("test data center"),
				Cluster:           pulumi.String("test cluster"),
				Folder:            pulumi.String("test folder"),
				CaCertData:        pulumi.String("test ca cert data"),
				Address:           pulumi.String("10.0.0.1"),
				DataDisk:          pulumi.String("test data disk"),
				StoragePolicyName: pulumi.String("storage_policy_name"),
			},
			NetworkConfig: &gkeonprem.VmwareAdminClusterNetworkConfigArgs{
				ServiceAddressCidrBlocks: pulumi.StringArray{
					pulumi.String("10.96.0.0/12"),
				},
				PodAddressCidrBlocks: pulumi.StringArray{
					pulumi.String("192.168.0.0/16"),
				},
				HaControlPlaneConfig: &gkeonprem.VmwareAdminClusterNetworkConfigHaControlPlaneConfigArgs{
					ControlPlaneIpBlock: &gkeonprem.VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockArgs{
						Gateway: pulumi.String("10.0.0.3"),
						Ips: gkeonprem.VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockIpArray{
							&gkeonprem.VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockIpArgs{
								Hostname: pulumi.String("hostname"),
								Ip:       pulumi.String("10.0.0.4"),
							},
						},
						Netmask: pulumi.String("10.0.0.3/32"),
					},
				},
				HostConfig: &gkeonprem.VmwareAdminClusterNetworkConfigHostConfigArgs{
					DnsServers: pulumi.StringArray{
						pulumi.String("10.254.41.1"),
					},
					NtpServers: pulumi.StringArray{
						pulumi.String("216.239.35.8"),
					},
					DnsSearchDomains: pulumi.StringArray{
						pulumi.String("test-domain"),
					},
				},
				StaticIpConfig: &gkeonprem.VmwareAdminClusterNetworkConfigStaticIpConfigArgs{
					IpBlocks: gkeonprem.VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockArray{
						&gkeonprem.VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockArgs{
							Gateway: pulumi.String("10.0.0.1"),
							Ips: gkeonprem.VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockIpArray{
								&gkeonprem.VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockIpArgs{
									Hostname: pulumi.String("hostname"),
									Ip:       pulumi.String("10.0.0.2"),
								},
							},
							Netmask: pulumi.String("10.0.0.3/32"),
						},
					},
				},
				VcenterNetwork: pulumi.String("test-vcenter-network"),
			},
			ControlPlaneNode: &gkeonprem.VmwareAdminClusterControlPlaneNodeArgs{
				Cpus:     pulumi.Int(4),
				Memory:   pulumi.Int(8192),
				Replicas: pulumi.Int(3),
			},
			LoadBalancer: &gkeonprem.VmwareAdminClusterLoadBalancerArgs{
				VipConfig: &gkeonprem.VmwareAdminClusterLoadBalancerVipConfigArgs{
					ControlPlaneVip: pulumi.String("10.251.133.5"),
					AddonsVip:       pulumi.String("10.251.135.19"),
				},
				ManualLbConfig: &gkeonprem.VmwareAdminClusterLoadBalancerManualLbConfigArgs{
					AddonsNodePort:             pulumi.Int(30005),
					ControlPlaneNodePort:       pulumi.Int(30006),
					IngressHttpNodePort:        pulumi.Int(30007),
					IngressHttpsNodePort:       pulumi.Int(30008),
					KonnectivityServerNodePort: pulumi.Int(30009),
				},
			},
			AddonNode: &gkeonprem.VmwareAdminClusterAddonNodeArgs{
				AutoResizeConfig: &gkeonprem.VmwareAdminClusterAddonNodeAutoResizeConfigArgs{
					Enabled: pulumi.Bool(true),
				},
			},
			AntiAffinityGroups: &gkeonprem.VmwareAdminClusterAntiAffinityGroupsArgs{
				AagConfigDisabled: pulumi.Bool(true),
			},
			Authorization: &gkeonprem.VmwareAdminClusterAuthorizationArgs{
				ViewerUsers: gkeonprem.VmwareAdminClusterAuthorizationViewerUserArray{
					&gkeonprem.VmwareAdminClusterAuthorizationViewerUserArgs{
						Username: pulumi.String("user1@gmail.com"),
					},
				},
			},
			AutoRepairConfig: &gkeonprem.VmwareAdminClusterAutoRepairConfigArgs{
				Enabled: pulumi.Bool(true),
			},
			PlatformConfig: &gkeonprem.VmwareAdminClusterPlatformConfigArgs{
				RequiredPlatformVersion: pulumi.String("1.31.0"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.gkeonprem.VmwareAdminCluster;
import com.pulumi.gcp.gkeonprem.VmwareAdminClusterArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterVcenterArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigHaControlPlaneConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigHostConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigStaticIpConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterControlPlaneNodeArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerVipConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerManualLbConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterAddonNodeArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterAddonNodeAutoResizeConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterAntiAffinityGroupsArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterAuthorizationArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterAutoRepairConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterPlatformConfigArgs;
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_full = new VmwareAdminCluster("admin-cluster-full", VmwareAdminClusterArgs.builder()
            .name("full")
            .location("us-west1")
            .description("test admin cluster")
            .bootstrapClusterMembership("projects/870316890899/locations/global/memberships/gkeonprem-terraform-test")
            .onPremVersion("1.31.0-gke.35")
            .imageType("ubuntu_containerd")
            .annotations(Map.ofEntries(
            ))
            .vcenter(VmwareAdminClusterVcenterArgs.builder()
                .resourcePool("test resource pool")
                .datastore("test data store")
                .datacenter("test data center")
                .cluster("test cluster")
                .folder("test folder")
                .caCertData("test ca cert data")
                .address("10.0.0.1")
                .dataDisk("test data disk")
                .storagePolicyName("storage_policy_name")
                .build())
            .networkConfig(VmwareAdminClusterNetworkConfigArgs.builder()
                .serviceAddressCidrBlocks("10.96.0.0/12")
                .podAddressCidrBlocks("192.168.0.0/16")
                .haControlPlaneConfig(VmwareAdminClusterNetworkConfigHaControlPlaneConfigArgs.builder()
                    .controlPlaneIpBlock(VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockArgs.builder()
                        .gateway("10.0.0.3")
                        .ips(VmwareAdminClusterNetworkConfigHaControlPlaneConfigControlPlaneIpBlockIpArgs.builder()
                            .hostname("hostname")
                            .ip("10.0.0.4")
                            .build())
                        .netmask("10.0.0.3/32")
                        .build())
                    .build())
                .hostConfig(VmwareAdminClusterNetworkConfigHostConfigArgs.builder()
                    .dnsServers("10.254.41.1")
                    .ntpServers("216.239.35.8")
                    .dnsSearchDomains("test-domain")
                    .build())
                .staticIpConfig(VmwareAdminClusterNetworkConfigStaticIpConfigArgs.builder()
                    .ipBlocks(VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockArgs.builder()
                        .gateway("10.0.0.1")
                        .ips(VmwareAdminClusterNetworkConfigStaticIpConfigIpBlockIpArgs.builder()
                            .hostname("hostname")
                            .ip("10.0.0.2")
                            .build())
                        .netmask("10.0.0.3/32")
                        .build())
                    .build())
                .vcenterNetwork("test-vcenter-network")
                .build())
            .controlPlaneNode(VmwareAdminClusterControlPlaneNodeArgs.builder()
                .cpus(4)
                .memory(8192)
                .replicas(3)
                .build())
            .loadBalancer(VmwareAdminClusterLoadBalancerArgs.builder()
                .vipConfig(VmwareAdminClusterLoadBalancerVipConfigArgs.builder()
                    .controlPlaneVip("10.251.133.5")
                    .addonsVip("10.251.135.19")
                    .build())
                .manualLbConfig(VmwareAdminClusterLoadBalancerManualLbConfigArgs.builder()
                    .addonsNodePort(30005)
                    .controlPlaneNodePort(30006)
                    .ingressHttpNodePort(30007)
                    .ingressHttpsNodePort(30008)
                    .konnectivityServerNodePort(30009)
                    .build())
                .build())
            .addonNode(VmwareAdminClusterAddonNodeArgs.builder()
                .autoResizeConfig(VmwareAdminClusterAddonNodeAutoResizeConfigArgs.builder()
                    .enabled(true)
                    .build())
                .build())
            .antiAffinityGroups(VmwareAdminClusterAntiAffinityGroupsArgs.builder()
                .aagConfigDisabled(true)
                .build())
            .authorization(VmwareAdminClusterAuthorizationArgs.builder()
                .viewerUsers(VmwareAdminClusterAuthorizationViewerUserArgs.builder()
                    .username("user1@gmail.com")
                    .build())
                .build())
            .autoRepairConfig(VmwareAdminClusterAutoRepairConfigArgs.builder()
                .enabled(true)
                .build())
            .platformConfig(VmwareAdminClusterPlatformConfigArgs.builder()
                .requiredPlatformVersion("1.31.0")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  admin-cluster-full:
    type: gcp:gkeonprem:VmwareAdminCluster
    properties:
      name: full
      location: us-west1
      description: test admin cluster
      bootstrapClusterMembership: projects/870316890899/locations/global/memberships/gkeonprem-terraform-test
      onPremVersion: 1.31.0-gke.35
      imageType: ubuntu_containerd
      annotations: {}
      vcenter:
        resourcePool: test resource pool
        datastore: test data store
        datacenter: test data center
        cluster: test cluster
        folder: test folder
        caCertData: test ca cert data
        address: 10.0.0.1
        dataDisk: test data disk
        storagePolicyName: storage_policy_name
      networkConfig:
        serviceAddressCidrBlocks:
          - 10.96.0.0/12
        podAddressCidrBlocks:
          - 192.168.0.0/16
        haControlPlaneConfig:
          controlPlaneIpBlock:
            gateway: 10.0.0.3
            ips:
              - hostname: hostname
                ip: 10.0.0.4
            netmask: 10.0.0.3/32
        hostConfig:
          dnsServers:
            - 10.254.41.1
          ntpServers:
            - 216.239.35.8
          dnsSearchDomains:
            - test-domain
        staticIpConfig:
          ipBlocks:
            - gateway: 10.0.0.1
              ips:
                - hostname: hostname
                  ip: 10.0.0.2
              netmask: 10.0.0.3/32
        vcenterNetwork: test-vcenter-network
      controlPlaneNode:
        cpus: 4
        memory: 8192
        replicas: 3
      loadBalancer:
        vipConfig:
          controlPlaneVip: 10.251.133.5
          addonsVip: 10.251.135.19
        manualLbConfig:
          addonsNodePort: 30005
          controlPlaneNodePort: 30006
          ingressHttpNodePort: 30007
          ingressHttpsNodePort: 30008
          konnectivityServerNodePort: 30009
      addonNode:
        autoResizeConfig:
          enabled: true
      antiAffinityGroups:
        aagConfigDisabled: true
      authorization:
        viewerUsers:
          - username: user1@gmail.com
      autoRepairConfig:
        enabled: true
      platformConfig:
        requiredPlatformVersion: 1.31.0
Content copied to clipboard

Gkeonprem Vmware Admin Cluster Metallb

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const admin_cluster_metallb = new gcp.gkeonprem.VmwareAdminCluster("admin-cluster-metallb", {
    name: "metallb",
    location: "us-west1",
    description: "test admin cluster",
    bootstrapClusterMembership: "projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
    onPremVersion: "1.31.0-gke.35",
    imageType: "ubuntu_containerd",
    vcenter: {
        resourcePool: "test resource pool",
        datastore: "test data store",
        datacenter: "test data center",
        cluster: "test cluster",
        folder: "test folder",
        caCertData: "test ca cert data",
        address: "10.0.0.1",
        dataDisk: "test data disk",
    },
    networkConfig: {
        serviceAddressCidrBlocks: ["10.96.0.0/12"],
        podAddressCidrBlocks: ["192.168.0.0/16"],
        dhcpIpConfig: {
            enabled: true,
        },
    },
    controlPlaneNode: {
        cpus: 4,
        memory: 8192,
    },
    loadBalancer: {
        vipConfig: {
            controlPlaneVip: "10.251.133.5",
            addonsVip: "10.251.135.19",
        },
        metalLbConfig: {
            enabled: true,
        },
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
admin_cluster_metallb = gcp.gkeonprem.VmwareAdminCluster("admin-cluster-metallb",
    name="metallb",
    location="us-west1",
    description="test admin cluster",
    bootstrap_cluster_membership="projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
    on_prem_version="1.31.0-gke.35",
    image_type="ubuntu_containerd",
    vcenter={
        "resource_pool": "test resource pool",
        "datastore": "test data store",
        "datacenter": "test data center",
        "cluster": "test cluster",
        "folder": "test folder",
        "ca_cert_data": "test ca cert data",
        "address": "10.0.0.1",
        "data_disk": "test data disk",
    },
    network_config={
        "service_address_cidr_blocks": ["10.96.0.0/12"],
        "pod_address_cidr_blocks": ["192.168.0.0/16"],
        "dhcp_ip_config": {
            "enabled": True,
        },
    },
    control_plane_node={
        "cpus": 4,
        "memory": 8192,
    },
    load_balancer={
        "vip_config": {
            "control_plane_vip": "10.251.133.5",
            "addons_vip": "10.251.135.19",
        },
        "metal_lb_config": {
            "enabled": True,
        },
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var admin_cluster_metallb = new Gcp.GkeOnPrem.VmwareAdminCluster("admin-cluster-metallb", new()
    {
        Name = "metallb",
        Location = "us-west1",
        Description = "test admin cluster",
        BootstrapClusterMembership = "projects/870316890899/locations/global/memberships/gkeonprem-terraform-test",
        OnPremVersion = "1.31.0-gke.35",
        ImageType = "ubuntu_containerd",
        Vcenter = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterVcenterArgs
        {
            ResourcePool = "test resource pool",
            Datastore = "test data store",
            Datacenter = "test data center",
            Cluster = "test cluster",
            Folder = "test folder",
            CaCertData = "test ca cert data",
            Address = "10.0.0.1",
            DataDisk = "test data disk",
        },
        NetworkConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigArgs
        {
            ServiceAddressCidrBlocks = new[]
            {
                "10.96.0.0/12",
            },
            PodAddressCidrBlocks = new[]
            {
                "192.168.0.0/16",
            },
            DhcpIpConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterNetworkConfigDhcpIpConfigArgs
            {
                Enabled = true,
            },
        },
        ControlPlaneNode = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterControlPlaneNodeArgs
        {
            Cpus = 4,
            Memory = 8192,
        },
        LoadBalancer = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerArgs
        {
            VipConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerVipConfigArgs
            {
                ControlPlaneVip = "10.251.133.5",
                AddonsVip = "10.251.135.19",
            },
            MetalLbConfig = new Gcp.GkeOnPrem.Inputs.VmwareAdminClusterLoadBalancerMetalLbConfigArgs
            {
                Enabled = true,
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/gkeonprem"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gkeonprem.NewVmwareAdminCluster(ctx, "admin-cluster-metallb", &gkeonprem.VmwareAdminClusterArgs{
			Name:                       pulumi.String("metallb"),
			Location:                   pulumi.String("us-west1"),
			Description:                pulumi.String("test admin cluster"),
			BootstrapClusterMembership: pulumi.String("projects/870316890899/locations/global/memberships/gkeonprem-terraform-test"),
			OnPremVersion:              pulumi.String("1.31.0-gke.35"),
			ImageType:                  pulumi.String("ubuntu_containerd"),
			Vcenter: &gkeonprem.VmwareAdminClusterVcenterArgs{
				ResourcePool: pulumi.String("test resource pool"),
				Datastore:    pulumi.String("test data store"),
				Datacenter:   pulumi.String("test data center"),
				Cluster:      pulumi.String("test cluster"),
				Folder:       pulumi.String("test folder"),
				CaCertData:   pulumi.String("test ca cert data"),
				Address:      pulumi.String("10.0.0.1"),
				DataDisk:     pulumi.String("test data disk"),
			},
			NetworkConfig: &gkeonprem.VmwareAdminClusterNetworkConfigArgs{
				ServiceAddressCidrBlocks: pulumi.StringArray{
					pulumi.String("10.96.0.0/12"),
				},
				PodAddressCidrBlocks: pulumi.StringArray{
					pulumi.String("192.168.0.0/16"),
				},
				DhcpIpConfig: &gkeonprem.VmwareAdminClusterNetworkConfigDhcpIpConfigArgs{
					Enabled: pulumi.Bool(true),
				},
			},
			ControlPlaneNode: &gkeonprem.VmwareAdminClusterControlPlaneNodeArgs{
				Cpus:   pulumi.Int(4),
				Memory: pulumi.Int(8192),
			},
			LoadBalancer: &gkeonprem.VmwareAdminClusterLoadBalancerArgs{
				VipConfig: &gkeonprem.VmwareAdminClusterLoadBalancerVipConfigArgs{
					ControlPlaneVip: pulumi.String("10.251.133.5"),
					AddonsVip:       pulumi.String("10.251.135.19"),
				},
				MetalLbConfig: &gkeonprem.VmwareAdminClusterLoadBalancerMetalLbConfigArgs{
					Enabled: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.gkeonprem.VmwareAdminCluster;
import com.pulumi.gcp.gkeonprem.VmwareAdminClusterArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterVcenterArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterNetworkConfigDhcpIpConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterControlPlaneNodeArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerVipConfigArgs;
import com.pulumi.gcp.gkeonprem.inputs.VmwareAdminClusterLoadBalancerMetalLbConfigArgs;
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_metallb = new VmwareAdminCluster("admin-cluster-metallb", VmwareAdminClusterArgs.builder()
            .name("metallb")
            .location("us-west1")
            .description("test admin cluster")
            .bootstrapClusterMembership("projects/870316890899/locations/global/memberships/gkeonprem-terraform-test")
            .onPremVersion("1.31.0-gke.35")
            .imageType("ubuntu_containerd")
            .vcenter(VmwareAdminClusterVcenterArgs.builder()
                .resourcePool("test resource pool")
                .datastore("test data store")
                .datacenter("test data center")
                .cluster("test cluster")
                .folder("test folder")
                .caCertData("test ca cert data")
                .address("10.0.0.1")
                .dataDisk("test data disk")
                .build())
            .networkConfig(VmwareAdminClusterNetworkConfigArgs.builder()
                .serviceAddressCidrBlocks("10.96.0.0/12")
                .podAddressCidrBlocks("192.168.0.0/16")
                .dhcpIpConfig(VmwareAdminClusterNetworkConfigDhcpIpConfigArgs.builder()
                    .enabled(true)
                    .build())
                .build())
            .controlPlaneNode(VmwareAdminClusterControlPlaneNodeArgs.builder()
                .cpus(4)
                .memory(8192)
                .build())
            .loadBalancer(VmwareAdminClusterLoadBalancerArgs.builder()
                .vipConfig(VmwareAdminClusterLoadBalancerVipConfigArgs.builder()
                    .controlPlaneVip("10.251.133.5")
                    .addonsVip("10.251.135.19")
                    .build())
                .metalLbConfig(VmwareAdminClusterLoadBalancerMetalLbConfigArgs.builder()
                    .enabled(true)
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  admin-cluster-metallb:
    type: gcp:gkeonprem:VmwareAdminCluster
    properties:
      name: metallb
      location: us-west1
      description: test admin cluster
      bootstrapClusterMembership: projects/870316890899/locations/global/memberships/gkeonprem-terraform-test
      onPremVersion: 1.31.0-gke.35
      imageType: ubuntu_containerd
      vcenter:
        resourcePool: test resource pool
        datastore: test data store
        datacenter: test data center
        cluster: test cluster
        folder: test folder
        caCertData: test ca cert data
        address: 10.0.0.1
        dataDisk: test data disk
      networkConfig:
        serviceAddressCidrBlocks:
          - 10.96.0.0/12
        podAddressCidrBlocks:
          - 192.168.0.0/16
        dhcpIpConfig:
          enabled: true
      controlPlaneNode:
        cpus: 4
        memory: 8192
      loadBalancer:
        vipConfig:
          controlPlaneVip: 10.251.133.5
          addonsVip: 10.251.135.19
        metalLbConfig:
          enabled: true
Content copied to clipboard

Import

VmwareAdminCluster can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/vmwareAdminClusters/{{name}}

  • {{project}}/{{location}}/{{name}}

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

$ pulumi import gcp:gkeonprem/vmwareAdminCluster:VmwareAdminCluster default projects/{{project}}/locations/{{location}}/vmwareAdminClusters/{{name}}
Content copied to clipboard
$ pulumi import gcp:gkeonprem/vmwareAdminCluster:VmwareAdminCluster default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:gkeonprem/vmwareAdminCluster:VmwareAdminCluster default {{location}}/{{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val addonNode: Output<VmwareAdminClusterAddonNode>

The VMware admin cluster addon node configuration.

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

Annotations on the VMware 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.

Link copied to clipboard
val antiAffinityGroups: Output<VmwareAdminClusterAntiAffinityGroups>

AAGConfig specifies whether to spread VMware Admin Cluster nodes across at least three physical hosts in the datacenter.

Link copied to clipboard
val authorization: Output<VmwareAdminClusterAuthorization>?

The VMware admin cluster authorization configuration.

Link copied to clipboard
val autoRepairConfig: Output<VmwareAdminClusterAutoRepairConfig>

Configuration for auto repairing.

Link copied to clipboard
val bootstrapClusterMembership: Output<String>

The bootstrap cluster this VMware admin cluster belongs to.

Link copied to clipboard
val controlPlaneNode: Output<VmwareAdminClusterControlPlaneNode>?

The VMware admin cluster control plane node configuration.

Link copied to clipboard
val createTime: Output<String>

The time the cluster was created, in RFC3339 text format.

Link copied to clipboard
val description: Output<String>

A human readable description of this VMware admin cluster.

Link copied to clipboard
Link copied to clipboard
val enableAdvancedCluster: Output<Boolean>

If set, the advanced cluster feature is enabled.

Link copied to clipboard
val endpoint: Output<String>

The DNS name of VMware admin cluster's API server.

Link copied to clipboard
val etag: Output<String>

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.

Link copied to clipboard
val fleets: Output<List<VmwareAdminClusterFleet>>

Fleet configuration for the cluster. Structure is documented below.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val imageType: Output<String>

The OS image type for the VMware admin cluster.

Link copied to clipboard
val loadBalancer: Output<VmwareAdminClusterLoadBalancer>?

Specifies the load balancer configuration for VMware admin cluster.

Link copied to clipboard
val localName: Output<String>

The object name of the VMwareAdminCluster 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.

Link copied to clipboard
val location: Output<String>

The location of the resource.

Link copied to clipboard
val name: Output<String>

The VMware admin cluster resource name.

Link copied to clipboard
val networkConfig: Output<VmwareAdminClusterNetworkConfig>

The VMware admin cluster network configuration. Structure is documented below.

Link copied to clipboard
val onPremVersion: Output<String>?

The Anthos clusters on the VMware version for the admin cluster.

Link copied to clipboard
val platformConfig: Output<VmwareAdminClusterPlatformConfig>?

The VMware platform configuration.

Link copied to clipboard
val project: Output<String>
Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val reconciling: Output<Boolean>

If set, there are currently changes in flight to the VMware admin cluster.

Link copied to clipboard
val state: Output<String>

(Output) The lifecycle state of the condition.

Link copied to clipboard
val statuses: Output<List<VmwareAdminClusterStatus>>

ResourceStatus representing detailed cluster state. Structure is documented below.

Link copied to clipboard
val uid: Output<String>

The unique identifier of the VMware Admin Cluster.

Link copied to clipboard
val updateTime: Output<String>

The time the cluster was last updated, in RFC3339 text format.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val vcenter: Output<VmwareAdminClusterVcenter>?

Specifies vCenter config for the admin cluster.