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

com.pulumi.gcp.tpu.kotlin.V2VmArgs.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.10.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.tpu.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.tpu.V2VmArgs.builder
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmAcceleratorConfigArgs
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmAcceleratorConfigArgsBuilder
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmDataDiskArgs
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmDataDiskArgsBuilder
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmNetworkConfigArgs
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmNetworkConfigArgsBuilder
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmSchedulingConfigArgs
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmSchedulingConfigArgsBuilder
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmServiceAccountArgs
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmServiceAccountArgsBuilder
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmShieldedInstanceConfigArgs
import com.pulumi.gcp.tpu.kotlin.inputs.V2VmShieldedInstanceConfigArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 * ## Example Usage
 * ### Tpu V2 Vm Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const available = gcp.tpu.getV2RuntimeVersions({});
 * const tpu = new gcp.tpu.V2Vm("tpu", {
 *     name: "test-tpu",
 *     zone: "us-central1-c",
 *     runtimeVersion: "tpu-vm-tf-2.13.0",
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * available = gcp.tpu.get_v2_runtime_versions()
 * tpu = gcp.tpu.V2Vm("tpu",
 *     name="test-tpu",
 *     zone="us-central1-c",
 *     runtime_version="tpu-vm-tf-2.13.0")
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var available = Gcp.Tpu.GetV2RuntimeVersions.Invoke();
 *     var tpu = new Gcp.Tpu.V2Vm("tpu", new()
 *     {
 *         Name = "test-tpu",
 *         Zone = "us-central1-c",
 *         RuntimeVersion = "tpu-vm-tf-2.13.0",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/tpu"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := tpu.GetV2RuntimeVersions(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = tpu.NewV2Vm(ctx, "tpu", &tpu.V2VmArgs{
 * 			Name:           pulumi.String("test-tpu"),
 * 			Zone:           pulumi.String("us-central1-c"),
 * 			RuntimeVersion: pulumi.String("tpu-vm-tf-2.13.0"),
 * 		})
 * 		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.tpu.TpuFunctions;
 * import com.pulumi.gcp.tpu.inputs.GetV2RuntimeVersionsArgs;
 * import com.pulumi.gcp.tpu.V2Vm;
 * import com.pulumi.gcp.tpu.V2VmArgs;
 * 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) {
 *         final var available = TpuFunctions.getV2RuntimeVersions();
 *         var tpu = new V2Vm("tpu", V2VmArgs.builder()
 *             .name("test-tpu")
 *             .zone("us-central1-c")
 *             .runtimeVersion("tpu-vm-tf-2.13.0")
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   tpu:
 *     type: gcp:tpu:V2Vm
 *     properties:
 *       name: test-tpu
 *       zone: us-central1-c
 *       runtimeVersion: tpu-vm-tf-2.13.0
 * variables:
 *   available:
 *     fn::invoke:
 *       Function: gcp:tpu:getV2RuntimeVersions
 *       Arguments: {}
 * ```
 * 
 * ### Tpu V2 Vm Full
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * import * as time from "@pulumi/time";
 * const available = gcp.tpu.getV2RuntimeVersions({});
 * const availableGetV2AcceleratorTypes = gcp.tpu.getV2AcceleratorTypes({});
 * const network = new gcp.compute.Network("network", {
 *     name: "tpu-net",
 *     autoCreateSubnetworks: false,
 * });
 * const subnet = new gcp.compute.Subnetwork("subnet", {
 *     name: "tpu-subnet",
 *     ipCidrRange: "10.0.0.0/16",
 *     region: "us-central1",
 *     network: network.id,
 * });
 * const sa = new gcp.serviceaccount.Account("sa", {
 *     accountId: "tpu-sa",
 *     displayName: "Test TPU VM",
 * });
 * const disk = new gcp.compute.Disk("disk", {
 *     name: "tpu-disk",
 *     image: "debian-cloud/debian-11",
 *     size: 10,
 *     type: "pd-ssd",
 *     zone: "us-central1-c",
 * });
 * const tpu = new gcp.tpu.V2Vm("tpu", {
 *     name: "test-tpu",
 *     zone: "us-central1-c",
 *     description: "Text description of the TPU.",
 *     runtimeVersion: "tpu-vm-tf-2.13.0",
 *     acceleratorConfig: {
 *         type: "V2",
 *         topology: "2x2",
 *     },
 *     cidrBlock: "10.0.0.0/29",
 *     networkConfig: {
 *         canIpForward: true,
 *         enableExternalIps: true,
 *         network: network.id,
 *         subnetwork: subnet.id,
 *     },
 *     schedulingConfig: {
 *         preemptible: true,
 *     },
 *     shieldedInstanceConfig: {
 *         enableSecureBoot: true,
 *     },
 *     serviceAccount: {
 *         email: sa.email,
 *         scopes: ["https://www.googleapis.com/auth/cloud-platform"],
 *     },
 *     dataDisks: [{
 *         sourceDisk: disk.id,
 *         mode: "READ_ONLY",
 *     }],
 *     labels: {
 *         foo: "bar",
 *     },
 *     metadata: {
 *         foo: "bar",
 *     },
 *     tags: ["foo"],
 * });
 * // Wait after service account creation to limit eventual consistency errors.
 * const wait60Seconds = new time.index.Sleep("wait_60_seconds", {createDuration: "60s"});
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * import pulumi_time as time
 * available = gcp.tpu.get_v2_runtime_versions()
 * available_get_v2_accelerator_types = gcp.tpu.get_v2_accelerator_types()
 * network = gcp.compute.Network("network",
 *     name="tpu-net",
 *     auto_create_subnetworks=False)
 * subnet = gcp.compute.Subnetwork("subnet",
 *     name="tpu-subnet",
 *     ip_cidr_range="10.0.0.0/16",
 *     region="us-central1",
 *     network=network.id)
 * sa = gcp.serviceaccount.Account("sa",
 *     account_id="tpu-sa",
 *     display_name="Test TPU VM")
 * disk = gcp.compute.Disk("disk",
 *     name="tpu-disk",
 *     image="debian-cloud/debian-11",
 *     size=10,
 *     type="pd-ssd",
 *     zone="us-central1-c")
 * tpu = gcp.tpu.V2Vm("tpu",
 *     name="test-tpu",
 *     zone="us-central1-c",
 *     description="Text description of the TPU.",
 *     runtime_version="tpu-vm-tf-2.13.0",
 *     accelerator_config=gcp.tpu.V2VmAcceleratorConfigArgs(
 *         type="V2",
 *         topology="2x2",
 *     ),
 *     cidr_block="10.0.0.0/29",
 *     network_config=gcp.tpu.V2VmNetworkConfigArgs(
 *         can_ip_forward=True,
 *         enable_external_ips=True,
 *         network=network.id,
 *         subnetwork=subnet.id,
 *     ),
 *     scheduling_config=gcp.tpu.V2VmSchedulingConfigArgs(
 *         preemptible=True,
 *     ),
 *     shielded_instance_config=gcp.tpu.V2VmShieldedInstanceConfigArgs(
 *         enable_secure_boot=True,
 *     ),
 *     service_account=gcp.tpu.V2VmServiceAccountArgs(
 *         email=sa.email,
 *         scopes=["https://www.googleapis.com/auth/cloud-platform"],
 *     ),
 *     data_disks=[gcp.tpu.V2VmDataDiskArgs(
 *         source_disk=disk.id,
 *         mode="READ_ONLY",
 *     )],
 *     labels={
 *         "foo": "bar",
 *     },
 *     metadata={
 *         "foo": "bar",
 *     },
 *     tags=["foo"])
 * # Wait after service account creation to limit eventual consistency errors.
 * wait60_seconds = time.index.Sleep("wait_60_seconds", create_duration=60s)
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * using Time = Pulumi.Time;
 * return await Deployment.RunAsync(() =>
 * {
 *     var available = Gcp.Tpu.GetV2RuntimeVersions.Invoke();
 *     var availableGetV2AcceleratorTypes = Gcp.Tpu.GetV2AcceleratorTypes.Invoke();
 *     var network = new Gcp.Compute.Network("network", new()
 *     {
 *         Name = "tpu-net",
 *         AutoCreateSubnetworks = false,
 *     });
 *     var subnet = new Gcp.Compute.Subnetwork("subnet", new()
 *     {
 *         Name = "tpu-subnet",
 *         IpCidrRange = "10.0.0.0/16",
 *         Region = "us-central1",
 *         Network = network.Id,
 *     });
 *     var sa = new Gcp.ServiceAccount.Account("sa", new()
 *     {
 *         AccountId = "tpu-sa",
 *         DisplayName = "Test TPU VM",
 *     });
 *     var disk = new Gcp.Compute.Disk("disk", new()
 *     {
 *         Name = "tpu-disk",
 *         Image = "debian-cloud/debian-11",
 *         Size = 10,
 *         Type = "pd-ssd",
 *         Zone = "us-central1-c",
 *     });
 *     var tpu = new Gcp.Tpu.V2Vm("tpu", new()
 *     {
 *         Name = "test-tpu",
 *         Zone = "us-central1-c",
 *         Description = "Text description of the TPU.",
 *         RuntimeVersion = "tpu-vm-tf-2.13.0",
 *         AcceleratorConfig = new Gcp.Tpu.Inputs.V2VmAcceleratorConfigArgs
 *         {
 *             Type = "V2",
 *             Topology = "2x2",
 *         },
 *         CidrBlock = "10.0.0.0/29",
 *         NetworkConfig = new Gcp.Tpu.Inputs.V2VmNetworkConfigArgs
 *         {
 *             CanIpForward = true,
 *             EnableExternalIps = true,
 *             Network = network.Id,
 *             Subnetwork = subnet.Id,
 *         },
 *         SchedulingConfig = new Gcp.Tpu.Inputs.V2VmSchedulingConfigArgs
 *         {
 *             Preemptible = true,
 *         },
 *         ShieldedInstanceConfig = new Gcp.Tpu.Inputs.V2VmShieldedInstanceConfigArgs
 *         {
 *             EnableSecureBoot = true,
 *         },
 *         ServiceAccount = new Gcp.Tpu.Inputs.V2VmServiceAccountArgs
 *         {
 *             Email = sa.Email,
 *             Scopes = new[]
 *             {
 *                 "https://www.googleapis.com/auth/cloud-platform",
 *             },
 *         },
 *         DataDisks = new[]
 *         {
 *             new Gcp.Tpu.Inputs.V2VmDataDiskArgs
 *             {
 *                 SourceDisk = disk.Id,
 *                 Mode = "READ_ONLY",
 *             },
 *         },
 *         Labels =
 *         {
 *             { "foo", "bar" },
 *         },
 *         Metadata =
 *         {
 *             { "foo", "bar" },
 *         },
 *         Tags = new[]
 *         {
 *             "foo",
 *         },
 *     });
 *     // Wait after service account creation to limit eventual consistency errors.
 *     var wait60Seconds = new Time.Index.Sleep("wait_60_seconds", new()
 *     {
 *         CreateDuration = "60s",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/serviceaccount"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/tpu"
 * 	"github.com/pulumi/pulumi-time/sdk/go/time"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := tpu.GetV2RuntimeVersions(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = tpu.GetV2AcceleratorTypes(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
 * 			Name:                  pulumi.String("tpu-net"),
 * 			AutoCreateSubnetworks: pulumi.Bool(false),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		subnet, err := compute.NewSubnetwork(ctx, "subnet", &compute.SubnetworkArgs{
 * 			Name:        pulumi.String("tpu-subnet"),
 * 			IpCidrRange: pulumi.String("10.0.0.0/16"),
 * 			Region:      pulumi.String("us-central1"),
 * 			Network:     network.ID(),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		sa, err := serviceaccount.NewAccount(ctx, "sa", &serviceaccount.AccountArgs{
 * 			AccountId:   pulumi.String("tpu-sa"),
 * 			DisplayName: pulumi.String("Test TPU VM"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		disk, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
 * 			Name:  pulumi.String("tpu-disk"),
 * 			Image: pulumi.String("debian-cloud/debian-11"),
 * 			Size:  pulumi.Int(10),
 * 			Type:  pulumi.String("pd-ssd"),
 * 			Zone:  pulumi.String("us-central1-c"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = tpu.NewV2Vm(ctx, "tpu", &tpu.V2VmArgs{
 * 			Name:           pulumi.String("test-tpu"),
 * 			Zone:           pulumi.String("us-central1-c"),
 * 			Description:    pulumi.String("Text description of the TPU."),
 * 			RuntimeVersion: pulumi.String("tpu-vm-tf-2.13.0"),
 * 			AcceleratorConfig: &tpu.V2VmAcceleratorConfigArgs{
 * 				Type:     pulumi.String("V2"),
 * 				Topology: pulumi.String("2x2"),
 * 			},
 * 			CidrBlock: pulumi.String("10.0.0.0/29"),
 * 			NetworkConfig: &tpu.V2VmNetworkConfigArgs{
 * 				CanIpForward:      pulumi.Bool(true),
 * 				EnableExternalIps: pulumi.Bool(true),
 * 				Network:           network.ID(),
 * 				Subnetwork:        subnet.ID(),
 * 			},
 * 			SchedulingConfig: &tpu.V2VmSchedulingConfigArgs{
 * 				Preemptible: pulumi.Bool(true),
 * 			},
 * 			ShieldedInstanceConfig: &tpu.V2VmShieldedInstanceConfigArgs{
 * 				EnableSecureBoot: pulumi.Bool(true),
 * 			},
 * 			ServiceAccount: &tpu.V2VmServiceAccountArgs{
 * 				Email: sa.Email,
 * 				Scopes: pulumi.StringArray{
 * 					pulumi.String("https://www.googleapis.com/auth/cloud-platform"),
 * 				},
 * 			},
 * 			DataDisks: tpu.V2VmDataDiskArray{
 * 				&tpu.V2VmDataDiskArgs{
 * 					SourceDisk: disk.ID(),
 * 					Mode:       pulumi.String("READ_ONLY"),
 * 				},
 * 			},
 * 			Labels: pulumi.StringMap{
 * 				"foo": pulumi.String("bar"),
 * 			},
 * 			Metadata: pulumi.StringMap{
 * 				"foo": pulumi.String("bar"),
 * 			},
 * 			Tags: pulumi.StringArray{
 * 				pulumi.String("foo"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		// Wait after service account creation to limit eventual consistency errors.
 * 		_, err = time.NewSleep(ctx, "wait_60_seconds", &time.SleepArgs{
 * 			CreateDuration: "60s",
 * 		})
 * 		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.tpu.TpuFunctions;
 * import com.pulumi.gcp.tpu.inputs.GetV2RuntimeVersionsArgs;
 * import com.pulumi.gcp.tpu.inputs.GetV2AcceleratorTypesArgs;
 * import com.pulumi.gcp.compute.Network;
 * import com.pulumi.gcp.compute.NetworkArgs;
 * import com.pulumi.gcp.compute.Subnetwork;
 * import com.pulumi.gcp.compute.SubnetworkArgs;
 * import com.pulumi.gcp.serviceaccount.Account;
 * import com.pulumi.gcp.serviceaccount.AccountArgs;
 * import com.pulumi.gcp.compute.Disk;
 * import com.pulumi.gcp.compute.DiskArgs;
 * import com.pulumi.gcp.tpu.V2Vm;
 * import com.pulumi.gcp.tpu.V2VmArgs;
 * import com.pulumi.gcp.tpu.inputs.V2VmAcceleratorConfigArgs;
 * import com.pulumi.gcp.tpu.inputs.V2VmNetworkConfigArgs;
 * import com.pulumi.gcp.tpu.inputs.V2VmSchedulingConfigArgs;
 * import com.pulumi.gcp.tpu.inputs.V2VmShieldedInstanceConfigArgs;
 * import com.pulumi.gcp.tpu.inputs.V2VmServiceAccountArgs;
 * import com.pulumi.gcp.tpu.inputs.V2VmDataDiskArgs;
 * import com.pulumi.time.sleep;
 * import com.pulumi.time.SleepArgs;
 * 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) {
 *         final var available = TpuFunctions.getV2RuntimeVersions();
 *         final var availableGetV2AcceleratorTypes = TpuFunctions.getV2AcceleratorTypes();
 *         var network = new Network("network", NetworkArgs.builder()
 *             .name("tpu-net")
 *             .autoCreateSubnetworks(false)
 *             .build());
 *         var subnet = new Subnetwork("subnet", SubnetworkArgs.builder()
 *             .name("tpu-subnet")
 *             .ipCidrRange("10.0.0.0/16")
 *             .region("us-central1")
 *             .network(network.id())
 *             .build());
 *         var sa = new Account("sa", AccountArgs.builder()
 *             .accountId("tpu-sa")
 *             .displayName("Test TPU VM")
 *             .build());
 *         var disk = new Disk("disk", DiskArgs.builder()
 *             .name("tpu-disk")
 *             .image("debian-cloud/debian-11")
 *             .size(10)
 *             .type("pd-ssd")
 *             .zone("us-central1-c")
 *             .build());
 *         var tpu = new V2Vm("tpu", V2VmArgs.builder()
 *             .name("test-tpu")
 *             .zone("us-central1-c")
 *             .description("Text description of the TPU.")
 *             .runtimeVersion("tpu-vm-tf-2.13.0")
 *             .acceleratorConfig(V2VmAcceleratorConfigArgs.builder()
 *                 .type("V2")
 *                 .topology("2x2")
 *                 .build())
 *             .cidrBlock("10.0.0.0/29")
 *             .networkConfig(V2VmNetworkConfigArgs.builder()
 *                 .canIpForward(true)
 *                 .enableExternalIps(true)
 *                 .network(network.id())
 *                 .subnetwork(subnet.id())
 *                 .build())
 *             .schedulingConfig(V2VmSchedulingConfigArgs.builder()
 *                 .preemptible(true)
 *                 .build())
 *             .shieldedInstanceConfig(V2VmShieldedInstanceConfigArgs.builder()
 *                 .enableSecureBoot(true)
 *                 .build())
 *             .serviceAccount(V2VmServiceAccountArgs.builder()
 *                 .email(sa.email())
 *                 .scopes("https://www.googleapis.com/auth/cloud-platform")
 *                 .build())
 *             .dataDisks(V2VmDataDiskArgs.builder()
 *                 .sourceDisk(disk.id())
 *                 .mode("READ_ONLY")
 *                 .build())
 *             .labels(Map.of("foo", "bar"))
 *             .metadata(Map.of("foo", "bar"))
 *             .tags("foo")
 *             .build());
 *         // Wait after service account creation to limit eventual consistency errors.
 *         var wait60Seconds = new Sleep("wait60Seconds", SleepArgs.builder()
 *             .createDuration("60s")
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   tpu:
 *     type: gcp:tpu:V2Vm
 *     properties:
 *       name: test-tpu
 *       zone: us-central1-c
 *       description: Text description of the TPU.
 *       runtimeVersion: tpu-vm-tf-2.13.0
 *       acceleratorConfig:
 *         type: V2
 *         topology: 2x2
 *       cidrBlock: 10.0.0.0/29
 *       networkConfig:
 *         canIpForward: true
 *         enableExternalIps: true
 *         network: ${network.id}
 *         subnetwork: ${subnet.id}
 *       schedulingConfig:
 *         preemptible: true
 *       shieldedInstanceConfig:
 *         enableSecureBoot: true
 *       serviceAccount:
 *         email: ${sa.email}
 *         scopes:
 *           - https://www.googleapis.com/auth/cloud-platform
 *       dataDisks:
 *         - sourceDisk: ${disk.id}
 *           mode: READ_ONLY
 *       labels:
 *         foo: bar
 *       metadata:
 *         foo: bar
 *       tags:
 *         - foo
 *   subnet:
 *     type: gcp:compute:Subnetwork
 *     properties:
 *       name: tpu-subnet
 *       ipCidrRange: 10.0.0.0/16
 *       region: us-central1
 *       network: ${network.id}
 *   network:
 *     type: gcp:compute:Network
 *     properties:
 *       name: tpu-net
 *       autoCreateSubnetworks: false
 *   sa:
 *     type: gcp:serviceaccount:Account
 *     properties:
 *       accountId: tpu-sa
 *       displayName: Test TPU VM
 *   disk:
 *     type: gcp:compute:Disk
 *     properties:
 *       name: tpu-disk
 *       image: debian-cloud/debian-11
 *       size: 10
 *       type: pd-ssd
 *       zone: us-central1-c
 *   # Wait after service account creation to limit eventual consistency errors.
 *   wait60Seconds:
 *     type: time:sleep
 *     name: wait_60_seconds
 *     properties:
 *       createDuration: 60s
 * variables:
 *   available:
 *     fn::invoke:
 *       Function: gcp:tpu:getV2RuntimeVersions
 *       Arguments: {}
 *   availableGetV2AcceleratorTypes:
 *     fn::invoke:
 *       Function: gcp:tpu:getV2AcceleratorTypes
 *       Arguments: {}
 * ```
 * 
 * ## Import
 * Vm can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{zone}}/nodes/{{name}}`
 * * `{{project}}/{{zone}}/{{name}}`
 * * `{{zone}}/{{name}}`
 * * `{{name}}`
 * When using the `pulumi import` command, Vm can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:tpu/v2Vm:V2Vm default projects/{{project}}/locations/{{zone}}/nodes/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:tpu/v2Vm:V2Vm default {{project}}/{{zone}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:tpu/v2Vm:V2Vm default {{zone}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:tpu/v2Vm:V2Vm default {{name}}
 * ```
 * @property acceleratorConfig The AccleratorConfig for the TPU Node. `accelerator_config` cannot be used at the same time
 * as `accelerator_type`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
 * Structure is documented below.
 * @property acceleratorType TPU accelerator type for the TPU. `accelerator_type` cannot be used at the same time as
 * `accelerator_config`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
 * @property cidrBlock The CIDR block that the TPU node will use when selecting an IP address. This CIDR block must
 * be a /29 block; the Compute Engine networks API forbids a smaller block, and using a larger
 * block would be wasteful (a node can only consume one IP address). Errors will occur if the
 * CIDR block has already been used for a currently existing TPU node, the CIDR block conflicts
 * with any subnetworks in the user's provided network, or the provided network is peered with
 * another network that is using that CIDR block.
 * @property dataDisks The additional data disks for the Node.
 * Structure is documented below.
 * @property description Text description of the TPU.
 * @property labels Resource labels to represent user-provided metadata.
 * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
 * Please refer to the field `effective_labels` for all of the labels present on the resource.
 * @property metadata Custom metadata to apply to the TPU Node. Can set startup-script and shutdown-script.
 * @property name The immutable name of the TPU.
 * @property networkConfig Network configurations for the TPU node.
 * Structure is documented below.
 * @property project The ID of the project in which the resource belongs.
 * If it is not provided, the provider project is used.
 * @property runtimeVersion Runtime version for the TPU.
 * - - -
 * @property schedulingConfig The scheduling options for this node.
 * Structure is documented below.
 * @property serviceAccount The Google Cloud Platform Service Account to be used by the TPU node VMs. If None is
 * specified, the default compute service account will be used.
 * Structure is documented below.
 * @property shieldedInstanceConfig Shielded Instance options.
 * Structure is documented below.
 * @property tags Tags to apply to the TPU Node. Tags are used to identify valid sources or targets for network firewalls.
 * @property zone The GCP location for the TPU. If it is not provided, the provider zone is used.
 */
public data class V2VmArgs(
    public val acceleratorConfig: Output? = null,
    public val acceleratorType: Output? = null,
    public val cidrBlock: Output? = null,
    public val dataDisks: Output>? = null,
    public val description: Output? = null,
    public val labels: Output>? = null,
    public val metadata: Output>? = null,
    public val name: Output? = null,
    public val networkConfig: Output? = null,
    public val project: Output? = null,
    public val runtimeVersion: Output? = null,
    public val schedulingConfig: Output? = null,
    public val serviceAccount: Output? = null,
    public val shieldedInstanceConfig: Output? = null,
    public val tags: Output>? = null,
    public val zone: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.tpu.V2VmArgs = com.pulumi.gcp.tpu.V2VmArgs.builder()
        .acceleratorConfig(acceleratorConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
        .acceleratorType(acceleratorType?.applyValue({ args0 -> args0 }))
        .cidrBlock(cidrBlock?.applyValue({ args0 -> args0 }))
        .dataDisks(
            dataDisks?.applyValue({ args0 ->
                args0.map({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                })
            }),
        )
        .description(description?.applyValue({ args0 -> args0 }))
        .labels(labels?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
        .metadata(
            metadata?.applyValue({ args0 ->
                args0.map({ args0 ->
                    args0.key.to(args0.value)
                }).toMap()
            }),
        )
        .name(name?.applyValue({ args0 -> args0 }))
        .networkConfig(networkConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
        .project(project?.applyValue({ args0 -> args0 }))
        .runtimeVersion(runtimeVersion?.applyValue({ args0 -> args0 }))
        .schedulingConfig(schedulingConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
        .serviceAccount(serviceAccount?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
        .shieldedInstanceConfig(
            shieldedInstanceConfig?.applyValue({ args0 ->
                args0.let({ args0 ->
                    args0.toJava()
                })
            }),
        )
        .tags(tags?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
        .zone(zone?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [V2VmArgs].
 */
@PulumiTagMarker
public class V2VmArgsBuilder internal constructor() {
    private var acceleratorConfig: Output? = null

    private var acceleratorType: Output? = null

    private var cidrBlock: Output? = null

    private var dataDisks: Output>? = null

    private var description: Output? = null

    private var labels: Output>? = null

    private var metadata: Output>? = null

    private var name: Output? = null

    private var networkConfig: Output? = null

    private var project: Output? = null

    private var runtimeVersion: Output? = null

    private var schedulingConfig: Output? = null

    private var serviceAccount: Output? = null

    private var shieldedInstanceConfig: Output? = null

    private var tags: Output>? = null

    private var zone: Output? = null

    /**
     * @param value The AccleratorConfig for the TPU Node. `accelerator_config` cannot be used at the same time
     * as `accelerator_type`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
     * Structure is documented below.
     */
    @JvmName("twknqvyawhdblkye")
    public suspend fun acceleratorConfig(`value`: Output) {
        this.acceleratorConfig = value
    }

    /**
     * @param value TPU accelerator type for the TPU. `accelerator_type` cannot be used at the same time as
     * `accelerator_config`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
     */
    @JvmName("sqnrklgktoypxvib")
    public suspend fun acceleratorType(`value`: Output) {
        this.acceleratorType = value
    }

    /**
     * @param value The CIDR block that the TPU node will use when selecting an IP address. This CIDR block must
     * be a /29 block; the Compute Engine networks API forbids a smaller block, and using a larger
     * block would be wasteful (a node can only consume one IP address). Errors will occur if the
     * CIDR block has already been used for a currently existing TPU node, the CIDR block conflicts
     * with any subnetworks in the user's provided network, or the provided network is peered with
     * another network that is using that CIDR block.
     */
    @JvmName("tesdsncdpggkacnl")
    public suspend fun cidrBlock(`value`: Output) {
        this.cidrBlock = value
    }

    /**
     * @param value The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("mekldyihnirmcuss")
    public suspend fun dataDisks(`value`: Output>) {
        this.dataDisks = value
    }

    @JvmName("xgfjlbtuergbputh")
    public suspend fun dataDisks(vararg values: Output) {
        this.dataDisks = Output.all(values.asList())
    }

    /**
     * @param values The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("qupgtphqpoopvnpy")
    public suspend fun dataDisks(values: List>) {
        this.dataDisks = Output.all(values)
    }

    /**
     * @param value Text description of the TPU.
     */
    @JvmName("fnsgjbusrswcdllw")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value Resource labels to represent user-provided metadata.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("qhmlsgbiimgyrbeb")
    public suspend fun labels(`value`: Output>) {
        this.labels = value
    }

    /**
     * @param value Custom metadata to apply to the TPU Node. Can set startup-script and shutdown-script.
     */
    @JvmName("vmlxefinobryrhsf")
    public suspend fun metadata(`value`: Output>) {
        this.metadata = value
    }

    /**
     * @param value The immutable name of the TPU.
     */
    @JvmName("ryrganugqxmdntov")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value Network configurations for the TPU node.
     * Structure is documented below.
     */
    @JvmName("qoixildiyxinsgot")
    public suspend fun networkConfig(`value`: Output) {
        this.networkConfig = value
    }

    /**
     * @param value The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    @JvmName("bqctgfnyttfcdvyj")
    public suspend fun project(`value`: Output) {
        this.project = value
    }

    /**
     * @param value Runtime version for the TPU.
     * - - -
     */
    @JvmName("mvgrdewtgppqyvpf")
    public suspend fun runtimeVersion(`value`: Output) {
        this.runtimeVersion = value
    }

    /**
     * @param value The scheduling options for this node.
     * Structure is documented below.
     */
    @JvmName("fqsixfljibhbjpbe")
    public suspend fun schedulingConfig(`value`: Output) {
        this.schedulingConfig = value
    }

    /**
     * @param value The Google Cloud Platform Service Account to be used by the TPU node VMs. If None is
     * specified, the default compute service account will be used.
     * Structure is documented below.
     */
    @JvmName("kxplsbuuopakjhiu")
    public suspend fun serviceAccount(`value`: Output) {
        this.serviceAccount = value
    }

    /**
     * @param value Shielded Instance options.
     * Structure is documented below.
     */
    @JvmName("hoshvchjlmxevinc")
    public suspend fun shieldedInstanceConfig(`value`: Output) {
        this.shieldedInstanceConfig = value
    }

    /**
     * @param value Tags to apply to the TPU Node. Tags are used to identify valid sources or targets for network firewalls.
     */
    @JvmName("lopiibaoulyartpl")
    public suspend fun tags(`value`: Output>) {
        this.tags = value
    }

    @JvmName("itxhwqlqlhnxavwt")
    public suspend fun tags(vararg values: Output) {
        this.tags = Output.all(values.asList())
    }

    /**
     * @param values Tags to apply to the TPU Node. Tags are used to identify valid sources or targets for network firewalls.
     */
    @JvmName("crqxpidusrrevjqy")
    public suspend fun tags(values: List>) {
        this.tags = Output.all(values)
    }

    /**
     * @param value The GCP location for the TPU. If it is not provided, the provider zone is used.
     */
    @JvmName("bsvvjcbdkwspupif")
    public suspend fun zone(`value`: Output) {
        this.zone = value
    }

    /**
     * @param value The AccleratorConfig for the TPU Node. `accelerator_config` cannot be used at the same time
     * as `accelerator_type`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
     * Structure is documented below.
     */
    @JvmName("lluevsvbwlreamda")
    public suspend fun acceleratorConfig(`value`: V2VmAcceleratorConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.acceleratorConfig = mapped
    }

    /**
     * @param argument The AccleratorConfig for the TPU Node. `accelerator_config` cannot be used at the same time
     * as `accelerator_type`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
     * Structure is documented below.
     */
    @JvmName("kilkgesiqdaqiqqm")
    public suspend fun acceleratorConfig(argument: suspend V2VmAcceleratorConfigArgsBuilder.() -> Unit) {
        val toBeMapped = V2VmAcceleratorConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.acceleratorConfig = mapped
    }

    /**
     * @param value TPU accelerator type for the TPU. `accelerator_type` cannot be used at the same time as
     * `accelerator_config`. If neither is specified, `accelerator_type` defaults to 'v2-8'.
     */
    @JvmName("vruaskdpwnftpjab")
    public suspend fun acceleratorType(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.acceleratorType = mapped
    }

    /**
     * @param value The CIDR block that the TPU node will use when selecting an IP address. This CIDR block must
     * be a /29 block; the Compute Engine networks API forbids a smaller block, and using a larger
     * block would be wasteful (a node can only consume one IP address). Errors will occur if the
     * CIDR block has already been used for a currently existing TPU node, the CIDR block conflicts
     * with any subnetworks in the user's provided network, or the provided network is peered with
     * another network that is using that CIDR block.
     */
    @JvmName("ksaepxvxghihblic")
    public suspend fun cidrBlock(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.cidrBlock = mapped
    }

    /**
     * @param value The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("kphothxkduvradgs")
    public suspend fun dataDisks(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataDisks = mapped
    }

    /**
     * @param argument The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("sdctosfrdtokpufc")
    public suspend fun dataDisks(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            V2VmDataDiskArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.dataDisks = mapped
    }

    /**
     * @param argument The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("cpftwiggdppjwgow")
    public suspend fun dataDisks(vararg argument: suspend V2VmDataDiskArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            V2VmDataDiskArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.dataDisks = mapped
    }

    /**
     * @param argument The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("orhixyoxuauowqhw")
    public suspend fun dataDisks(argument: suspend V2VmDataDiskArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(V2VmDataDiskArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.dataDisks = mapped
    }

    /**
     * @param values The additional data disks for the Node.
     * Structure is documented below.
     */
    @JvmName("lvjpoiijmmsyyjol")
    public suspend fun dataDisks(vararg values: V2VmDataDiskArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.dataDisks = mapped
    }

    /**
     * @param value Text description of the TPU.
     */
    @JvmName("gbpyltumwmhbpjpl")
    public suspend fun description(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.description = mapped
    }

    /**
     * @param value Resource labels to represent user-provided metadata.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("rkukpqpfiwhnyoro")
    public suspend fun labels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param values Resource labels to represent user-provided metadata.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("prbwqqdujhfsmhll")
    public fun labels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param value Custom metadata to apply to the TPU Node. Can set startup-script and shutdown-script.
     */
    @JvmName("ucltcwbriqbujynt")
    public suspend fun metadata(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.metadata = mapped
    }

    /**
     * @param values Custom metadata to apply to the TPU Node. Can set startup-script and shutdown-script.
     */
    @JvmName("wsanahdxxunkiqdd")
    public fun metadata(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.metadata = mapped
    }

    /**
     * @param value The immutable name of the TPU.
     */
    @JvmName("vyiqdvhtoytnxbcp")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value Network configurations for the TPU node.
     * Structure is documented below.
     */
    @JvmName("svskqdhvsfejsepa")
    public suspend fun networkConfig(`value`: V2VmNetworkConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.networkConfig = mapped
    }

    /**
     * @param argument Network configurations for the TPU node.
     * Structure is documented below.
     */
    @JvmName("dyghdonvdgktlhpr")
    public suspend fun networkConfig(argument: suspend V2VmNetworkConfigArgsBuilder.() -> Unit) {
        val toBeMapped = V2VmNetworkConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.networkConfig = mapped
    }

    /**
     * @param value The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    @JvmName("ykuitpwuqqtcfdca")
    public suspend fun project(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.project = mapped
    }

    /**
     * @param value Runtime version for the TPU.
     * - - -
     */
    @JvmName("pfhkrmtjitpekutg")
    public suspend fun runtimeVersion(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.runtimeVersion = mapped
    }

    /**
     * @param value The scheduling options for this node.
     * Structure is documented below.
     */
    @JvmName("cxmigrfmdibnrneu")
    public suspend fun schedulingConfig(`value`: V2VmSchedulingConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.schedulingConfig = mapped
    }

    /**
     * @param argument The scheduling options for this node.
     * Structure is documented below.
     */
    @JvmName("qsqbypisoynctgcy")
    public suspend fun schedulingConfig(argument: suspend V2VmSchedulingConfigArgsBuilder.() -> Unit) {
        val toBeMapped = V2VmSchedulingConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.schedulingConfig = mapped
    }

    /**
     * @param value The Google Cloud Platform Service Account to be used by the TPU node VMs. If None is
     * specified, the default compute service account will be used.
     * Structure is documented below.
     */
    @JvmName("whveodqswkuasmdg")
    public suspend fun serviceAccount(`value`: V2VmServiceAccountArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.serviceAccount = mapped
    }

    /**
     * @param argument The Google Cloud Platform Service Account to be used by the TPU node VMs. If None is
     * specified, the default compute service account will be used.
     * Structure is documented below.
     */
    @JvmName("clitbygutccgbleq")
    public suspend fun serviceAccount(argument: suspend V2VmServiceAccountArgsBuilder.() -> Unit) {
        val toBeMapped = V2VmServiceAccountArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.serviceAccount = mapped
    }

    /**
     * @param value Shielded Instance options.
     * Structure is documented below.
     */
    @JvmName("uxltjamcyywlylmw")
    public suspend fun shieldedInstanceConfig(`value`: V2VmShieldedInstanceConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.shieldedInstanceConfig = mapped
    }

    /**
     * @param argument Shielded Instance options.
     * Structure is documented below.
     */
    @JvmName("vypxncnomlsifots")
    public suspend fun shieldedInstanceConfig(argument: suspend V2VmShieldedInstanceConfigArgsBuilder.() -> Unit) {
        val toBeMapped = V2VmShieldedInstanceConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.shieldedInstanceConfig = mapped
    }

    /**
     * @param value Tags to apply to the TPU Node. Tags are used to identify valid sources or targets for network firewalls.
     */
    @JvmName("hfgnblfbwurukdnw")
    public suspend fun tags(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.tags = mapped
    }

    /**
     * @param values Tags to apply to the TPU Node. Tags are used to identify valid sources or targets for network firewalls.
     */
    @JvmName("mgujpotouqqktccd")
    public suspend fun tags(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.tags = mapped
    }

    /**
     * @param value The GCP location for the TPU. If it is not provided, the provider zone is used.
     */
    @JvmName("rbnknxqllkyatobn")
    public suspend fun zone(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.zone = mapped
    }

    internal fun build(): V2VmArgs = V2VmArgs(
        acceleratorConfig = acceleratorConfig,
        acceleratorType = acceleratorType,
        cidrBlock = cidrBlock,
        dataDisks = dataDisks,
        description = description,
        labels = labels,
        metadata = metadata,
        name = name,
        networkConfig = networkConfig,
        project = project,
        runtimeVersion = runtimeVersion,
        schedulingConfig = schedulingConfig,
        serviceAccount = serviceAccount,
        shieldedInstanceConfig = shieldedInstanceConfig,
        tags = tags,
        zone = zone,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy