Skip to content

GCP.VMwareEngine reference

Source: packages/gcp/src/VMwareEngine/Datastore.ts

A Google Cloud VMware Engine NFS datastore.

Datastores have no labels field, so Alchemy stamps ownership into the description for list / nuke. Changing datastoreId, location, or the NFS backend identity replaces the datastore. Description updates in place.

Filestore-backed NFS datastore

const datastore = yield* GCP.VMwareEngine.Datastore("Nfs", {
nfsDatastore: {
googleFileService: {
filestoreInstance:
"projects/my-project/locations/us-central1-a/instances/share",
},
},
description: "app nfs datastore",
});

Third-party NFS

const datastore = yield* GCP.VMwareEngine.Datastore("VendorNfs", {
nfsDatastore: {
thirdPartyFileService: {
servers: ["10.1.2.3"],
network: "projects/my-project/global/networks/default",
fileShare: "vol1",
},
},
});

Datastore: Looking up an existing datastore

Section titled “Datastore: Looking up an existing datastore”

Datastore.lookup references a datastore Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared datastore.

const datastore = GCP.VMwareEngine.Datastore.lookup({
datastoreId: "my-datastore",
});

Source: packages/gcp/src/VMwareEngine/NetworkPeering.ts

A peering between a VMware Engine network and a VPC or another VMware Engine network. NetworkPeering is a global resource.

Network peerings have no labels field, so Alchemy stamps ownership into the description for list / nuke. Identity, peer network, peer type, and VMware Engine network are immutable. Description updates in place.

const peering = yield* GCP.VMwareEngine.NetworkPeering("ToVpc", {
vmwareEngineNetwork: ven.name,
peerNetwork: "projects/my-project/global/networks/default",
peerNetworkType: "STANDARD",
description: "gcve to vpc",
});

NetworkPeering: Looking up an existing network peering

Section titled “NetworkPeering: Looking up an existing network peering”

NetworkPeering.lookup references a network peering Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared network peering.

const networkPeering = GCP.VMwareEngine.NetworkPeering.lookup({
networkPeeringId: "my-network-peering",
});

Source: packages/gcp/src/VMwareEngine/NetworkPoliciesExternalAccessRule.ts

An inbound firewall rule on a VMware Engine network policy that filters traffic destined to ExternalAddress resources.

Rules have no labels field, so Alchemy stamps ownership into the description for list / nuke. Changing the parent policy, rule id, or location replaces the rule. Priority, action, protocol, ranges, ports, and description update in place.

NetworkPoliciesExternalAccessRule: Creating a NetworkPoliciesExternalAccessRule

Section titled “NetworkPoliciesExternalAccessRule: Creating a NetworkPoliciesExternalAccessRule”
const rule = yield* GCP.VMwareEngine.NetworkPoliciesExternalAccessRule(
"Https",
{
networkPolicy: policy.name,
action: "ALLOW",
ipProtocol: "tcp",
priority: 1000,
sourceIpRanges: [{ ipAddressRange: "0.0.0.0/0" }],
sourcePorts: ["0-65535"],
destinationIpRanges: [{ ipAddressRange: "0.0.0.0/0" }],
destinationPorts: ["443"],
description: "allow https",
},
);

NetworkPoliciesExternalAccessRule: Looking up an existing network policies external access rule

Section titled “NetworkPoliciesExternalAccessRule: Looking up an existing network policies external access rule”

NetworkPoliciesExternalAccessRule.lookup references a network policies external access rule Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared network policies external access rule.

const networkPoliciesExternalAccessRule = GCP.VMwareEngine.NetworkPoliciesExternalAccessRule.lookup({
externalAccessRuleId: "my-external-access-rule",
networkPolicy: "my-network-policy",
});

Source: packages/gcp/src/VMwareEngine/NetworkPolicy.ts

A regional VMware Engine network policy that controls internet and external IP access for private clouds on a VMware Engine network.

Network policies have no labels field, so Alchemy stamps ownership into the description for list / nuke. Changing networkPolicyId, location, or vmwareEngineNetwork replaces the policy. CIDR, internet access, external IP, and description update in place.

const policy = yield* GCP.VMwareEngine.NetworkPolicy("Edge", {
vmwareEngineNetwork: ven.name,
edgeServicesCidr: "192.168.100.0/26",
internetAccess: { enabled: false },
externalIp: { enabled: false },
description: "edge policy",
});

NetworkPolicy: Looking up an existing network policy

Section titled “NetworkPolicy: Looking up an existing network policy”

NetworkPolicy.lookup references a network policy Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared network policy.

const networkPolicy = GCP.VMwareEngine.NetworkPolicy.lookup({
networkPolicyId: "my-network-policy",
});

Source: packages/gcp/src/VMwareEngine/PrivateCloud.ts

A Google Cloud VMware Engine private cloud. STANDARD and TIME_LIMITED clouds are zonal; STRETCHED clouds are regional. Creating a private cloud also creates its management cluster.

Private clouds have no labels field, so Alchemy stamps ownership into the description for list / nuke. Type, location, management cluster identity, and network config are immutable. Description updates in place. Delete uses delayHours=0 so billing stops immediately.

Provisioning typically takes 30-120 minutes.

const cloud = yield* GCP.VMwareEngine.PrivateCloud("Sddc", {
location: "us-central1-a",
type: "STANDARD",
networkConfig: {
managementCidr: "192.168.1.0/24",
vmwareEngineNetwork: ven.name,
},
managementCluster: {
clusterId: "mgmt",
nodeTypeConfigs: {
"standard-72": { nodeCount: 3 },
},
},
description: "app sddc",
});

PrivateCloud: Looking up an existing private cloud

Section titled “PrivateCloud: Looking up an existing private cloud”

PrivateCloud.lookup references a private cloud Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared private cloud.

const privateCloud = GCP.VMwareEngine.PrivateCloud.lookup({
privateCloudId: "my-private-cloud",
});

Source: packages/gcp/src/VMwareEngine/PrivateCloudsCluster.ts

A workload cluster in a VMware Engine private cloud. The management cluster is created with the private cloud and cannot be deleted independently.

Clusters have no labels or description field, so Alchemy treats clusters whose parent private cloud carries the [alchemy …] ownership marker as owned for list / nuke. Changing the parent cloud, cluster id, location, or stretched config replaces the cluster. Node counts and autoscaling update in place.

PrivateCloudsCluster: Creating a PrivateCloudsCluster

Section titled “PrivateCloudsCluster: Creating a PrivateCloudsCluster”
const cluster = yield* GCP.VMwareEngine.PrivateCloudsCluster("Work", {
privateCloud: cloud.name,
nodeTypeConfigs: {
"standard-72": { nodeCount: 3 },
},
});

PrivateCloudsCluster: Looking up an existing private clouds cluster

Section titled “PrivateCloudsCluster: Looking up an existing private clouds cluster”

PrivateCloudsCluster.lookup references a private clouds cluster Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared private clouds cluster.

const privateCloudsCluster = GCP.VMwareEngine.PrivateCloudsCluster.lookup({
clusterId: "my-cluster",
privateCloud: "my-private-cloud",
});

Source: packages/gcp/src/VMwareEngine/PrivateCloudsExternalAddress.ts

An allocated external IP address mapped to a workload VM inside a VMware Engine private cloud. The corresponding network policy must have externalIp enabled.

External addresses have no labels field, so Alchemy stamps ownership into the description for list / nuke. Changing the parent cloud, address id, or location replaces the address. Internal IP and description update in place.

PrivateCloudsExternalAddress: Creating a PrivateCloudsExternalAddress

Section titled “PrivateCloudsExternalAddress: Creating a PrivateCloudsExternalAddress”
const address = yield* GCP.VMwareEngine.PrivateCloudsExternalAddress(
"Web",
{
privateCloud: cloud.name,
internalIp: "192.168.1.10",
description: "web vip",
},
);

PrivateCloudsExternalAddress: Looking up an existing private clouds external address

Section titled “PrivateCloudsExternalAddress: Looking up an existing private clouds external address”

PrivateCloudsExternalAddress.lookup references a private clouds external address Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared private clouds external address.

const privateCloudsExternalAddress = GCP.VMwareEngine.PrivateCloudsExternalAddress.lookup({
externalAddressId: "my-external-address",
privateCloud: "my-private-cloud",
});

Source: packages/gcp/src/VMwareEngine/PrivateCloudsLoggingServer.ts

A syslog destination that receives vCenter or ESXi logs from a VMware Engine private cloud.

Logging servers have no labels or description field, so Alchemy treats servers whose parent private cloud carries the [alchemy …] ownership marker as owned for list / nuke. Changing the parent cloud, server id, or location replaces the server. Hostname, port, protocol, and source type update in place.

PrivateCloudsLoggingServer: Creating a PrivateCloudsLoggingServer

Section titled “PrivateCloudsLoggingServer: Creating a PrivateCloudsLoggingServer”
const syslog = yield* GCP.VMwareEngine.PrivateCloudsLoggingServer(
"Esxi",
{
privateCloud: cloud.name,
hostname: "logs.example.com",
port: 514,
protocol: "UDP",
sourceType: "ESXI",
},
);

PrivateCloudsLoggingServer: Looking up an existing private clouds logging server

Section titled “PrivateCloudsLoggingServer: Looking up an existing private clouds logging server”

PrivateCloudsLoggingServer.lookup references a private clouds logging server Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared private clouds logging server.

const privateCloudsLoggingServer = GCP.VMwareEngine.PrivateCloudsLoggingServer.lookup({
loggingServerId: "my-logging-server",
privateCloud: "my-private-cloud",
});

Source: packages/gcp/src/VMwareEngine/PrivateCloudsManagementDnsZoneBinding.ts

A binding between a consumer VPC (or VMware Engine network) and a private cloud’s management DNS zone.

The management DNS zone holds FQDNs for ESXi hosts and management appliances (vCenter, NSX Manager). Changing the parent private cloud, binding id, or bound network replaces the binding. Description updates in place.

PrivateCloudsManagementDnsZoneBinding: Creating a Binding

Section titled “PrivateCloudsManagementDnsZoneBinding: Creating a Binding”

Bind a consumer VPC

const binding = yield* GCP.VMwareEngine.PrivateCloudsManagementDnsZoneBinding(
"VpcDns",
{
privateCloud: cloud.name,
vpcNetwork: "projects/my-project/global/networks/default",
description: "consumer vpc",
},
);

Bind a VMware Engine network

const binding = yield* GCP.VMwareEngine.PrivateCloudsManagementDnsZoneBinding(
"VenDns",
{
privateCloud: cloud.name,
vmwareEngineNetwork: ven.name,
description: "standard ven",
},
);

PrivateCloudsManagementDnsZoneBinding: Updating a Binding

Section titled “PrivateCloudsManagementDnsZoneBinding: Updating a Binding”

Re-declare the same logical id with changed props; the engine keeps the physical resource and updates it in place.

const binding = yield* GCP.VMwareEngine.PrivateCloudsManagementDnsZoneBinding(
"VpcDns",
{
privateCloud: cloud.name,
vpcNetwork: "projects/my-project/global/networks/default",
description: "consumer vpc v2",
},
);

Source: packages/gcp/src/VMwareEngine/PrivateConnection.ts

A private connection that peers a service VPC with a VMware Engine network so private clouds can reach Google Cloud services, NetApp, Dell PowerScale, or a third-party VPC.

Changing id, location, type, vmwareEngineNetwork, or serviceNetwork replaces the connection. Description and routing mode update in place.

Third-party VPC

const connection = yield* GCP.VMwareEngine.PrivateConnection("Peer", {
type: "THIRD_PARTY_SERVICE",
vmwareEngineNetwork: ven.name,
serviceNetwork: "projects/my-project/global/networks/default",
description: "consumer vpc",
});

Private Service Access

const connection = yield* GCP.VMwareEngine.PrivateConnection("Psa", {
location: "us-central1",
type: "PRIVATE_SERVICE_ACCESS",
vmwareEngineNetwork: ven.name,
serviceNetwork:
"projects/my-project/global/networks/servicenetworking",
routingMode: "GLOBAL",
});

Re-declare the same logical id with changed props; the engine keeps the physical resource and updates it in place.

const connection = yield* GCP.VMwareEngine.PrivateConnection("Psa", {
location: "us-central1",
type: "PRIVATE_SERVICE_ACCESS",
vmwareEngineNetwork: ven.name,
serviceNetwork:
"projects/my-project/global/networks/servicenetworking",
routingMode: "REGIONAL",
description: "psa v2",
});

PrivateConnection: Looking up an existing private connection

Section titled “PrivateConnection: Looking up an existing private connection”

PrivateConnection.lookup references a private connection Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared private connection.

const privateConnection = GCP.VMwareEngine.PrivateConnection.lookup({
privateConnectionId: "my-private-connection",
});

Source: packages/gcp/src/VMwareEngine/VmwareEngineNetwork.ts

A VMware Engine network that private clouds attach to for intranet, internet, and Google Cloud connectivity.

STANDARD networks live at locations/global. LEGACY networks are regional singletons named {region}-default. Changing id, location, or type replaces the network. Description updates in place.

Generated STANDARD network

const network = yield* GCP.VMwareEngine.VmwareEngineNetwork("Ven", {
type: "STANDARD",
description: "app network",
});

Named STANDARD network

const network = yield* GCP.VMwareEngine.VmwareEngineNetwork("Ven", {
vmwareEngineNetworkId: "app-ven",
location: "global",
type: "STANDARD",
description: "prod network",
});

VmwareEngineNetwork: Legacy regional network

Section titled “VmwareEngineNetwork: Legacy regional network”
const network = yield* GCP.VMwareEngine.VmwareEngineNetwork("Legacy", {
location: "us-central1",
type: "LEGACY",
description: "legacy default",
});

Re-declare the same logical id with changed props; the engine keeps the physical resource and updates it in place.

const network = yield* GCP.VMwareEngine.VmwareEngineNetwork("Ven", {
location: "global",
type: "STANDARD",
description: "prod network v2",
});

VmwareEngineNetwork: Looking up an existing vmware engine network

Section titled “VmwareEngineNetwork: Looking up an existing vmware engine network”

VmwareEngineNetwork.lookup references a vmware engine network Alchemy doesn’t manage (created in the console or by another stack). It is read during plan/deploy, never created, updated or deleted, and binds like a declared vmware engine network.

const vmwareEngineNetwork = GCP.VMwareEngine.VmwareEngineNetwork.lookup({
vmwareEngineNetworkId: "my-vmware-engine-network",
});