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

com.pulumi.gcp.datafusion.kotlin.InstanceArgs.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.datafusion.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.datafusion.InstanceArgs.builder
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceAcceleratorArgs
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceAcceleratorArgsBuilder
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceCryptoKeyConfigArgs
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceCryptoKeyConfigArgsBuilder
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceEventPublishConfigArgs
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceEventPublishConfigArgsBuilder
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceNetworkConfigArgs
import com.pulumi.gcp.datafusion.kotlin.inputs.InstanceNetworkConfigArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 * Represents a Data Fusion instance.
 * To get more information about Instance, see:
 * * [API documentation](https://cloud.google.com/data-fusion/docs/reference/rest/v1beta1/projects.locations.instances)
 * * How-to Guides
 *     * [Official Documentation](https://cloud.google.com/data-fusion/docs/)
 * ## Example Usage
 * ### Data Fusion Instance Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const basicInstance = new gcp.datafusion.Instance("basic_instance", {
 *     name: "my-instance",
 *     region: "us-central1",
 *     type: "BASIC",
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * basic_instance = gcp.datafusion.Instance("basic_instance",
 *     name="my-instance",
 *     region="us-central1",
 *     type="BASIC")
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var basicInstance = new Gcp.DataFusion.Instance("basic_instance", new()
 *     {
 *         Name = "my-instance",
 *         Region = "us-central1",
 *         Type = "BASIC",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datafusion"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := datafusion.NewInstance(ctx, "basic_instance", &datafusion.InstanceArgs{
 * 			Name:   pulumi.String("my-instance"),
 * 			Region: pulumi.String("us-central1"),
 * 			Type:   pulumi.String("BASIC"),
 * 		})
 * 		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.datafusion.Instance;
 * import com.pulumi.gcp.datafusion.InstanceArgs;
 * 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 basicInstance = new Instance("basicInstance", InstanceArgs.builder()
 *             .name("my-instance")
 *             .region("us-central1")
 *             .type("BASIC")
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   basicInstance:
 *     type: gcp:datafusion:Instance
 *     name: basic_instance
 *     properties:
 *       name: my-instance
 *       region: us-central1
 *       type: BASIC
 * ```
 * 
 * ### Data Fusion Instance Full
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const default = gcp.appengine.getDefaultServiceAccount({});
 * const network = new gcp.compute.Network("network", {name: "datafusion-full-network"});
 * const privateIpAlloc = new gcp.compute.GlobalAddress("private_ip_alloc", {
 *     name: "datafusion-ip-alloc",
 *     addressType: "INTERNAL",
 *     purpose: "VPC_PEERING",
 *     prefixLength: 22,
 *     network: network.id,
 * });
 * const extendedInstance = new gcp.datafusion.Instance("extended_instance", {
 *     name: "my-instance",
 *     description: "My Data Fusion instance",
 *     displayName: "My Data Fusion instance",
 *     region: "us-central1",
 *     type: "BASIC",
 *     enableStackdriverLogging: true,
 *     enableStackdriverMonitoring: true,
 *     privateInstance: true,
 *     dataprocServiceAccount: _default.then(_default => _default.email),
 *     labels: {
 *         example_key: "example_value",
 *     },
 *     networkConfig: {
 *         network: "default",
 *         ipAllocation: pulumi.interpolate`${privateIpAlloc.address}/${privateIpAlloc.prefixLength}`,
 *     },
 *     accelerators: [{
 *         acceleratorType: "CDC",
 *         state: "ENABLED",
 *     }],
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * default = gcp.appengine.get_default_service_account()
 * network = gcp.compute.Network("network", name="datafusion-full-network")
 * private_ip_alloc = gcp.compute.GlobalAddress("private_ip_alloc",
 *     name="datafusion-ip-alloc",
 *     address_type="INTERNAL",
 *     purpose="VPC_PEERING",
 *     prefix_length=22,
 *     network=network.id)
 * extended_instance = gcp.datafusion.Instance("extended_instance",
 *     name="my-instance",
 *     description="My Data Fusion instance",
 *     display_name="My Data Fusion instance",
 *     region="us-central1",
 *     type="BASIC",
 *     enable_stackdriver_logging=True,
 *     enable_stackdriver_monitoring=True,
 *     private_instance=True,
 *     dataproc_service_account=default.email,
 *     labels={
 *         "example_key": "example_value",
 *     },
 *     network_config=gcp.datafusion.InstanceNetworkConfigArgs(
 *         network="default",
 *         ip_allocation=pulumi.Output.all(private_ip_alloc.address, private_ip_alloc.prefix_length).apply(lambda address, prefix_length: f"{address}/{prefix_length}"),
 *     ),
 *     accelerators=[gcp.datafusion.InstanceAcceleratorArgs(
 *         accelerator_type="CDC",
 *         state="ENABLED",
 *     )])
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var @default = Gcp.AppEngine.GetDefaultServiceAccount.Invoke();
 *     var network = new Gcp.Compute.Network("network", new()
 *     {
 *         Name = "datafusion-full-network",
 *     });
 *     var privateIpAlloc = new Gcp.Compute.GlobalAddress("private_ip_alloc", new()
 *     {
 *         Name = "datafusion-ip-alloc",
 *         AddressType = "INTERNAL",
 *         Purpose = "VPC_PEERING",
 *         PrefixLength = 22,
 *         Network = network.Id,
 *     });
 *     var extendedInstance = new Gcp.DataFusion.Instance("extended_instance", new()
 *     {
 *         Name = "my-instance",
 *         Description = "My Data Fusion instance",
 *         DisplayName = "My Data Fusion instance",
 *         Region = "us-central1",
 *         Type = "BASIC",
 *         EnableStackdriverLogging = true,
 *         EnableStackdriverMonitoring = true,
 *         PrivateInstance = true,
 *         DataprocServiceAccount = @default.Apply(@default => @default.Apply(getDefaultServiceAccountResult => getDefaultServiceAccountResult.Email)),
 *         Labels =
 *         {
 *             { "example_key", "example_value" },
 *         },
 *         NetworkConfig = new Gcp.DataFusion.Inputs.InstanceNetworkConfigArgs
 *         {
 *             Network = "default",
 *             IpAllocation = Output.Tuple(privateIpAlloc.Address, privateIpAlloc.PrefixLength).Apply(values =>
 *             {
 *                 var address = values.Item1;
 *                 var prefixLength = values.Item2;
 *                 return $"{address}/{prefixLength}";
 *             }),
 *         },
 *         Accelerators = new[]
 *         {
 *             new Gcp.DataFusion.Inputs.InstanceAcceleratorArgs
 *             {
 *                 AcceleratorType = "CDC",
 *                 State = "ENABLED",
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/appengine"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datafusion"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_default, err := appengine.GetDefaultServiceAccount(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
 * 			Name: pulumi.String("datafusion-full-network"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		privateIpAlloc, err := compute.NewGlobalAddress(ctx, "private_ip_alloc", &compute.GlobalAddressArgs{
 * 			Name:         pulumi.String("datafusion-ip-alloc"),
 * 			AddressType:  pulumi.String("INTERNAL"),
 * 			Purpose:      pulumi.String("VPC_PEERING"),
 * 			PrefixLength: pulumi.Int(22),
 * 			Network:      network.ID(),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = datafusion.NewInstance(ctx, "extended_instance", &datafusion.InstanceArgs{
 * 			Name:                        pulumi.String("my-instance"),
 * 			Description:                 pulumi.String("My Data Fusion instance"),
 * 			DisplayName:                 pulumi.String("My Data Fusion instance"),
 * 			Region:                      pulumi.String("us-central1"),
 * 			Type:                        pulumi.String("BASIC"),
 * 			EnableStackdriverLogging:    pulumi.Bool(true),
 * 			EnableStackdriverMonitoring: pulumi.Bool(true),
 * 			PrivateInstance:             pulumi.Bool(true),
 * 			DataprocServiceAccount:      pulumi.String(_default.Email),
 * 			Labels: pulumi.StringMap{
 * 				"example_key": pulumi.String("example_value"),
 * 			},
 * 			NetworkConfig: &datafusion.InstanceNetworkConfigArgs{
 * 				Network: pulumi.String("default"),
 * 				IpAllocation: pulumi.All(privateIpAlloc.Address, privateIpAlloc.PrefixLength).ApplyT(func(_args []interface{}) (string, error) {
 * 					address := _args[0].(string)
 * 					prefixLength := _args[1].(int)
 * 					return fmt.Sprintf("%v/%v", address, prefixLength), nil
 * 				}).(pulumi.StringOutput),
 * 			},
 * 			Accelerators: datafusion.InstanceAcceleratorArray{
 * 				&datafusion.InstanceAcceleratorArgs{
 * 					AcceleratorType: pulumi.String("CDC"),
 * 					State:           pulumi.String("ENABLED"),
 * 				},
 * 			},
 * 		})
 * 		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.appengine.AppengineFunctions;
 * import com.pulumi.gcp.appengine.inputs.GetDefaultServiceAccountArgs;
 * import com.pulumi.gcp.compute.Network;
 * import com.pulumi.gcp.compute.NetworkArgs;
 * import com.pulumi.gcp.compute.GlobalAddress;
 * import com.pulumi.gcp.compute.GlobalAddressArgs;
 * import com.pulumi.gcp.datafusion.Instance;
 * import com.pulumi.gcp.datafusion.InstanceArgs;
 * import com.pulumi.gcp.datafusion.inputs.InstanceNetworkConfigArgs;
 * import com.pulumi.gcp.datafusion.inputs.InstanceAcceleratorArgs;
 * 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 default = AppengineFunctions.getDefaultServiceAccount();
 *         var network = new Network("network", NetworkArgs.builder()
 *             .name("datafusion-full-network")
 *             .build());
 *         var privateIpAlloc = new GlobalAddress("privateIpAlloc", GlobalAddressArgs.builder()
 *             .name("datafusion-ip-alloc")
 *             .addressType("INTERNAL")
 *             .purpose("VPC_PEERING")
 *             .prefixLength(22)
 *             .network(network.id())
 *             .build());
 *         var extendedInstance = new Instance("extendedInstance", InstanceArgs.builder()
 *             .name("my-instance")
 *             .description("My Data Fusion instance")
 *             .displayName("My Data Fusion instance")
 *             .region("us-central1")
 *             .type("BASIC")
 *             .enableStackdriverLogging(true)
 *             .enableStackdriverMonitoring(true)
 *             .privateInstance(true)
 *             .dataprocServiceAccount(default_.email())
 *             .labels(Map.of("example_key", "example_value"))
 *             .networkConfig(InstanceNetworkConfigArgs.builder()
 *                 .network("default")
 *                 .ipAllocation(Output.tuple(privateIpAlloc.address(), privateIpAlloc.prefixLength()).applyValue(values -> {
 *                     var address = values.t1;
 *                     var prefixLength = values.t2;
 *                     return String.format("%s/%s", address,prefixLength);
 *                 }))
 *                 .build())
 *             .accelerators(InstanceAcceleratorArgs.builder()
 *                 .acceleratorType("CDC")
 *                 .state("ENABLED")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   extendedInstance:
 *     type: gcp:datafusion:Instance
 *     name: extended_instance
 *     properties:
 *       name: my-instance
 *       description: My Data Fusion instance
 *       displayName: My Data Fusion instance
 *       region: us-central1
 *       type: BASIC
 *       enableStackdriverLogging: true
 *       enableStackdriverMonitoring: true
 *       privateInstance: true
 *       dataprocServiceAccount: ${default.email}
 *       labels:
 *         example_key: example_value
 *       networkConfig:
 *         network: default
 *         ipAllocation: ${privateIpAlloc.address}/${privateIpAlloc.prefixLength}
 *       accelerators:
 *         - acceleratorType: CDC
 *           state: ENABLED
 *   network:
 *     type: gcp:compute:Network
 *     properties:
 *       name: datafusion-full-network
 *   privateIpAlloc:
 *     type: gcp:compute:GlobalAddress
 *     name: private_ip_alloc
 *     properties:
 *       name: datafusion-ip-alloc
 *       addressType: INTERNAL
 *       purpose: VPC_PEERING
 *       prefixLength: 22
 *       network: ${network.id}
 * variables:
 *   default:
 *     fn::invoke:
 *       Function: gcp:appengine:getDefaultServiceAccount
 *       Arguments: {}
 * ```
 * 
 * ### Data Fusion Instance Cmek
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const keyRing = new gcp.kms.KeyRing("key_ring", {
 *     name: "my-instance",
 *     location: "us-central1",
 * });
 * const cryptoKey = new gcp.kms.CryptoKey("crypto_key", {
 *     name: "my-instance",
 *     keyRing: keyRing.id,
 * });
 * const cmek = new gcp.datafusion.Instance("cmek", {
 *     name: "my-instance",
 *     region: "us-central1",
 *     type: "BASIC",
 *     cryptoKeyConfig: {
 *         keyReference: cryptoKey.id,
 *     },
 * });
 * const project = gcp.organizations.getProject({});
 * const cryptoKeyMember = new gcp.kms.CryptoKeyIAMMember("crypto_key_member", {
 *     cryptoKeyId: cryptoKey.id,
 *     role: "roles/cloudkms.cryptoKeyEncrypterDecrypter",
 *     member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-datafusion.iam.gserviceaccount.com`),
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * key_ring = gcp.kms.KeyRing("key_ring",
 *     name="my-instance",
 *     location="us-central1")
 * crypto_key = gcp.kms.CryptoKey("crypto_key",
 *     name="my-instance",
 *     key_ring=key_ring.id)
 * cmek = gcp.datafusion.Instance("cmek",
 *     name="my-instance",
 *     region="us-central1",
 *     type="BASIC",
 *     crypto_key_config=gcp.datafusion.InstanceCryptoKeyConfigArgs(
 *         key_reference=crypto_key.id,
 *     ))
 * project = gcp.organizations.get_project()
 * crypto_key_member = gcp.kms.CryptoKeyIAMMember("crypto_key_member",
 *     crypto_key_id=crypto_key.id,
 *     role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
 *     member=f"serviceAccount:service-{project.number}@gcp-sa-datafusion.iam.gserviceaccount.com")
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var keyRing = new Gcp.Kms.KeyRing("key_ring", new()
 *     {
 *         Name = "my-instance",
 *         Location = "us-central1",
 *     });
 *     var cryptoKey = new Gcp.Kms.CryptoKey("crypto_key", new()
 *     {
 *         Name = "my-instance",
 *         KeyRing = keyRing.Id,
 *     });
 *     var cmek = new Gcp.DataFusion.Instance("cmek", new()
 *     {
 *         Name = "my-instance",
 *         Region = "us-central1",
 *         Type = "BASIC",
 *         CryptoKeyConfig = new Gcp.DataFusion.Inputs.InstanceCryptoKeyConfigArgs
 *         {
 *             KeyReference = cryptoKey.Id,
 *         },
 *     });
 *     var project = Gcp.Organizations.GetProject.Invoke();
 *     var cryptoKeyMember = new Gcp.Kms.CryptoKeyIAMMember("crypto_key_member", new()
 *     {
 *         CryptoKeyId = cryptoKey.Id,
 *         Role = "roles/cloudkms.cryptoKeyEncrypterDecrypter",
 *         Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-datafusion.iam.gserviceaccount.com",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datafusion"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/kms"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		keyRing, err := kms.NewKeyRing(ctx, "key_ring", &kms.KeyRingArgs{
 * 			Name:     pulumi.String("my-instance"),
 * 			Location: pulumi.String("us-central1"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		cryptoKey, err := kms.NewCryptoKey(ctx, "crypto_key", &kms.CryptoKeyArgs{
 * 			Name:    pulumi.String("my-instance"),
 * 			KeyRing: keyRing.ID(),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = datafusion.NewInstance(ctx, "cmek", &datafusion.InstanceArgs{
 * 			Name:   pulumi.String("my-instance"),
 * 			Region: pulumi.String("us-central1"),
 * 			Type:   pulumi.String("BASIC"),
 * 			CryptoKeyConfig: &datafusion.InstanceCryptoKeyConfigArgs{
 * 				KeyReference: cryptoKey.ID(),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		project, err := organizations.LookupProject(ctx, nil, nil)
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = kms.NewCryptoKeyIAMMember(ctx, "crypto_key_member", &kms.CryptoKeyIAMMemberArgs{
 * 			CryptoKeyId: cryptoKey.ID(),
 * 			Role:        pulumi.String("roles/cloudkms.cryptoKeyEncrypterDecrypter"),
 * 			Member:      pulumi.String(fmt.Sprintf("serviceAccount:service-%[email protected]", project.Number)),
 * 		})
 * 		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.kms.KeyRing;
 * import com.pulumi.gcp.kms.KeyRingArgs;
 * import com.pulumi.gcp.kms.CryptoKey;
 * import com.pulumi.gcp.kms.CryptoKeyArgs;
 * import com.pulumi.gcp.datafusion.Instance;
 * import com.pulumi.gcp.datafusion.InstanceArgs;
 * import com.pulumi.gcp.datafusion.inputs.InstanceCryptoKeyConfigArgs;
 * import com.pulumi.gcp.organizations.OrganizationsFunctions;
 * import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
 * import com.pulumi.gcp.kms.CryptoKeyIAMMember;
 * import com.pulumi.gcp.kms.CryptoKeyIAMMemberArgs;
 * 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 keyRing = new KeyRing("keyRing", KeyRingArgs.builder()
 *             .name("my-instance")
 *             .location("us-central1")
 *             .build());
 *         var cryptoKey = new CryptoKey("cryptoKey", CryptoKeyArgs.builder()
 *             .name("my-instance")
 *             .keyRing(keyRing.id())
 *             .build());
 *         var cmek = new Instance("cmek", InstanceArgs.builder()
 *             .name("my-instance")
 *             .region("us-central1")
 *             .type("BASIC")
 *             .cryptoKeyConfig(InstanceCryptoKeyConfigArgs.builder()
 *                 .keyReference(cryptoKey.id())
 *                 .build())
 *             .build());
 *         final var project = OrganizationsFunctions.getProject();
 *         var cryptoKeyMember = new CryptoKeyIAMMember("cryptoKeyMember", CryptoKeyIAMMemberArgs.builder()
 *             .cryptoKeyId(cryptoKey.id())
 *             .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
 *             .member(String.format("serviceAccount:service-%[email protected]", project.applyValue(getProjectResult -> getProjectResult.number())))
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   cmek:
 *     type: gcp:datafusion:Instance
 *     properties:
 *       name: my-instance
 *       region: us-central1
 *       type: BASIC
 *       cryptoKeyConfig:
 *         keyReference: ${cryptoKey.id}
 *   cryptoKey:
 *     type: gcp:kms:CryptoKey
 *     name: crypto_key
 *     properties:
 *       name: my-instance
 *       keyRing: ${keyRing.id}
 *   keyRing:
 *     type: gcp:kms:KeyRing
 *     name: key_ring
 *     properties:
 *       name: my-instance
 *       location: us-central1
 *   cryptoKeyMember:
 *     type: gcp:kms:CryptoKeyIAMMember
 *     name: crypto_key_member
 *     properties:
 *       cryptoKeyId: ${cryptoKey.id}
 *       role: roles/cloudkms.cryptoKeyEncrypterDecrypter
 *       member: serviceAccount:service-${project.number}@gcp-sa-datafusion.iam.gserviceaccount.com
 * variables:
 *   project:
 *     fn::invoke:
 *       Function: gcp:organizations:getProject
 *       Arguments: {}
 * ```
 * 
 * ### Data Fusion Instance Enterprise
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const enterpriseInstance = new gcp.datafusion.Instance("enterprise_instance", {
 *     name: "my-instance",
 *     region: "us-central1",
 *     type: "ENTERPRISE",
 *     enableRbac: true,
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * enterprise_instance = gcp.datafusion.Instance("enterprise_instance",
 *     name="my-instance",
 *     region="us-central1",
 *     type="ENTERPRISE",
 *     enable_rbac=True)
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var enterpriseInstance = new Gcp.DataFusion.Instance("enterprise_instance", new()
 *     {
 *         Name = "my-instance",
 *         Region = "us-central1",
 *         Type = "ENTERPRISE",
 *         EnableRbac = true,
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datafusion"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := datafusion.NewInstance(ctx, "enterprise_instance", &datafusion.InstanceArgs{
 * 			Name:       pulumi.String("my-instance"),
 * 			Region:     pulumi.String("us-central1"),
 * 			Type:       pulumi.String("ENTERPRISE"),
 * 			EnableRbac: pulumi.Bool(true),
 * 		})
 * 		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.datafusion.Instance;
 * import com.pulumi.gcp.datafusion.InstanceArgs;
 * 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 enterpriseInstance = new Instance("enterpriseInstance", InstanceArgs.builder()
 *             .name("my-instance")
 *             .region("us-central1")
 *             .type("ENTERPRISE")
 *             .enableRbac(true)
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   enterpriseInstance:
 *     type: gcp:datafusion:Instance
 *     name: enterprise_instance
 *     properties:
 *       name: my-instance
 *       region: us-central1
 *       type: ENTERPRISE
 *       enableRbac: true
 * ```
 * 
 * ### Data Fusion Instance Event
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const eventTopic = new gcp.pubsub.Topic("event", {name: "my-instance"});
 * const event = new gcp.datafusion.Instance("event", {
 *     name: "my-instance",
 *     region: "us-central1",
 *     type: "BASIC",
 *     eventPublishConfig: {
 *         enabled: true,
 *         topic: eventTopic.id,
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * event_topic = gcp.pubsub.Topic("event", name="my-instance")
 * event = gcp.datafusion.Instance("event",
 *     name="my-instance",
 *     region="us-central1",
 *     type="BASIC",
 *     event_publish_config=gcp.datafusion.InstanceEventPublishConfigArgs(
 *         enabled=True,
 *         topic=event_topic.id,
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var eventTopic = new Gcp.PubSub.Topic("event", new()
 *     {
 *         Name = "my-instance",
 *     });
 *     var @event = new Gcp.DataFusion.Instance("event", new()
 *     {
 *         Name = "my-instance",
 *         Region = "us-central1",
 *         Type = "BASIC",
 *         EventPublishConfig = new Gcp.DataFusion.Inputs.InstanceEventPublishConfigArgs
 *         {
 *             Enabled = true,
 *             Topic = eventTopic.Id,
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datafusion"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/pubsub"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		eventTopic, err := pubsub.NewTopic(ctx, "event", &pubsub.TopicArgs{
 * 			Name: pulumi.String("my-instance"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = datafusion.NewInstance(ctx, "event", &datafusion.InstanceArgs{
 * 			Name:   pulumi.String("my-instance"),
 * 			Region: pulumi.String("us-central1"),
 * 			Type:   pulumi.String("BASIC"),
 * 			EventPublishConfig: &datafusion.InstanceEventPublishConfigArgs{
 * 				Enabled: pulumi.Bool(true),
 * 				Topic:   eventTopic.ID(),
 * 			},
 * 		})
 * 		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.pubsub.Topic;
 * import com.pulumi.gcp.pubsub.TopicArgs;
 * import com.pulumi.gcp.datafusion.Instance;
 * import com.pulumi.gcp.datafusion.InstanceArgs;
 * import com.pulumi.gcp.datafusion.inputs.InstanceEventPublishConfigArgs;
 * 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 eventTopic = new Topic("eventTopic", TopicArgs.builder()
 *             .name("my-instance")
 *             .build());
 *         var event = new Instance("event", InstanceArgs.builder()
 *             .name("my-instance")
 *             .region("us-central1")
 *             .type("BASIC")
 *             .eventPublishConfig(InstanceEventPublishConfigArgs.builder()
 *                 .enabled(true)
 *                 .topic(eventTopic.id())
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   event:
 *     type: gcp:datafusion:Instance
 *     properties:
 *       name: my-instance
 *       region: us-central1
 *       type: BASIC
 *       eventPublishConfig:
 *         enabled: true
 *         topic: ${eventTopic.id}
 *   eventTopic:
 *     type: gcp:pubsub:Topic
 *     name: event
 *     properties:
 *       name: my-instance
 * ```
 * 
 * ### Data Fusion Instance Zone
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const zone = new gcp.datafusion.Instance("zone", {
 *     name: "my-instance",
 *     region: "us-central1",
 *     zone: "us-central1-a",
 *     type: "DEVELOPER",
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * zone = gcp.datafusion.Instance("zone",
 *     name="my-instance",
 *     region="us-central1",
 *     zone="us-central1-a",
 *     type="DEVELOPER")
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var zone = new Gcp.DataFusion.Instance("zone", new()
 *     {
 *         Name = "my-instance",
 *         Region = "us-central1",
 *         Zone = "us-central1-a",
 *         Type = "DEVELOPER",
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datafusion"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := datafusion.NewInstance(ctx, "zone", &datafusion.InstanceArgs{
 * 			Name:   pulumi.String("my-instance"),
 * 			Region: pulumi.String("us-central1"),
 * 			Zone:   pulumi.String("us-central1-a"),
 * 			Type:   pulumi.String("DEVELOPER"),
 * 		})
 * 		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.datafusion.Instance;
 * import com.pulumi.gcp.datafusion.InstanceArgs;
 * 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 zone = new Instance("zone", InstanceArgs.builder()
 *             .name("my-instance")
 *             .region("us-central1")
 *             .zone("us-central1-a")
 *             .type("DEVELOPER")
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   zone:
 *     type: gcp:datafusion:Instance
 *     properties:
 *       name: my-instance
 *       region: us-central1
 *       zone: us-central1-a
 *       type: DEVELOPER
 * ```
 * 
 * ## Import
 * Instance can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{region}}/instances/{{name}}`
 * * `{{project}}/{{region}}/{{name}}`
 * * `{{region}}/{{name}}`
 * * `{{name}}`
 * When using the `pulumi import` command, Instance can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:datafusion/instance:Instance default projects/{{project}}/locations/{{region}}/instances/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:datafusion/instance:Instance default {{project}}/{{region}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:datafusion/instance:Instance default {{region}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:datafusion/instance:Instance default {{name}}
 * ```
 * @property accelerators List of accelerators enabled for this CDF instance.
 * If accelerators are enabled it is possible a permadiff will be created with the Options field.
 * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
 * Structure is documented below.
 * @property cryptoKeyConfig The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
 * Structure is documented below.
 * @property dataprocServiceAccount User-managed service account to set on Dataproc when Cloud Data Fusion creates Dataproc to run data processing pipelines.
 * @property description An optional description of the instance.
 * @property displayName Display name for an instance.
 * @property enableRbac Option to enable granular role-based access control.
 * @property enableStackdriverLogging Option to enable Stackdriver Logging.
 * @property enableStackdriverMonitoring Option to enable Stackdriver Monitoring.
 * @property eventPublishConfig Option to enable and pass metadata for event publishing.
 * Structure is documented below.
 * @property labels The resource labels for instance to use to annotate any related underlying resources,
 * such as Compute Engine VMs.
 * **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 name The ID of the instance or a fully qualified identifier for the instance.
 * @property networkConfig Network configuration options. These are required when a private Data Fusion instance is to be created.
 * Structure is documented below.
 * @property options Map of additional options used to configure the behavior of Data Fusion instance.
 * @property privateInstance Specifies whether the Data Fusion instance should be private. If set to
 * true, all Data Fusion nodes will have private IP addresses and will not be
 * able to access the public internet.
 * @property project The ID of the project in which the resource belongs.
 * If it is not provided, the provider project is used.
 * @property region The region of the Data Fusion instance.
 * @property type Represents the type of Data Fusion instance. Each type is configured with
 * the default settings for processing and memory.
 * - BASIC: Basic Data Fusion instance. In Basic type, the user will be able to create data pipelines
 * using point and click UI. However, there are certain limitations, such as fewer number
 * of concurrent pipelines, no support for streaming pipelines, etc.
 * - ENTERPRISE: Enterprise Data Fusion instance. In Enterprise type, the user will have more features
 * available, such as support for streaming pipelines, higher number of concurrent pipelines, etc.
 * - DEVELOPER: Developer Data Fusion instance. In Developer type, the user will have all features available but
 * with restrictive capabilities. This is to help enterprises design and develop their data ingestion and integration
 * pipelines at low cost.
 * Possible values are: `BASIC`, `ENTERPRISE`, `DEVELOPER`.
 * - - -
 * @property version Current version of the Data Fusion.
 * @property zone Name of the zone in which the Data Fusion instance will be created. Only DEVELOPER instances use this field.
 */
public data class InstanceArgs(
    public val accelerators: Output>? = null,
    public val cryptoKeyConfig: Output? = null,
    public val dataprocServiceAccount: Output? = null,
    public val description: Output? = null,
    public val displayName: Output? = null,
    public val enableRbac: Output? = null,
    public val enableStackdriverLogging: Output? = null,
    public val enableStackdriverMonitoring: Output? = null,
    public val eventPublishConfig: Output? = null,
    public val labels: Output>? = null,
    public val name: Output? = null,
    public val networkConfig: Output? = null,
    public val options: Output>? = null,
    public val privateInstance: Output? = null,
    public val project: Output? = null,
    public val region: Output? = null,
    public val type: Output? = null,
    public val version: Output? = null,
    public val zone: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.datafusion.InstanceArgs =
        com.pulumi.gcp.datafusion.InstanceArgs.builder()
            .accelerators(
                accelerators?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .cryptoKeyConfig(cryptoKeyConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .dataprocServiceAccount(dataprocServiceAccount?.applyValue({ args0 -> args0 }))
            .description(description?.applyValue({ args0 -> args0 }))
            .displayName(displayName?.applyValue({ args0 -> args0 }))
            .enableRbac(enableRbac?.applyValue({ args0 -> args0 }))
            .enableStackdriverLogging(enableStackdriverLogging?.applyValue({ args0 -> args0 }))
            .enableStackdriverMonitoring(enableStackdriverMonitoring?.applyValue({ args0 -> args0 }))
            .eventPublishConfig(
                eventPublishConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .labels(labels?.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() }) }))
            .options(options?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .privateInstance(privateInstance?.applyValue({ args0 -> args0 }))
            .project(project?.applyValue({ args0 -> args0 }))
            .region(region?.applyValue({ args0 -> args0 }))
            .type(type?.applyValue({ args0 -> args0 }))
            .version(version?.applyValue({ args0 -> args0 }))
            .zone(zone?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [InstanceArgs].
 */
@PulumiTagMarker
public class InstanceArgsBuilder internal constructor() {
    private var accelerators: Output>? = null

    private var cryptoKeyConfig: Output? = null

    private var dataprocServiceAccount: Output? = null

    private var description: Output? = null

    private var displayName: Output? = null

    private var enableRbac: Output? = null

    private var enableStackdriverLogging: Output? = null

    private var enableStackdriverMonitoring: Output? = null

    private var eventPublishConfig: Output? = null

    private var labels: Output>? = null

    private var name: Output? = null

    private var networkConfig: Output? = null

    private var options: Output>? = null

    private var privateInstance: Output? = null

    private var project: Output? = null

    private var region: Output? = null

    private var type: Output? = null

    private var version: Output? = null

    private var zone: Output? = null

    /**
     * @param value List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("elsivyewylubepmh")
    public suspend fun accelerators(`value`: Output>) {
        this.accelerators = value
    }

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

    /**
     * @param values List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("uljcylicsxlcakkx")
    public suspend fun accelerators(values: List>) {
        this.accelerators = Output.all(values)
    }

    /**
     * @param value The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
     * Structure is documented below.
     */
    @JvmName("appkitaldtunvikf")
    public suspend fun cryptoKeyConfig(`value`: Output) {
        this.cryptoKeyConfig = value
    }

    /**
     * @param value User-managed service account to set on Dataproc when Cloud Data Fusion creates Dataproc to run data processing pipelines.
     */
    @JvmName("lpxdnfaxjhrjpfkg")
    public suspend fun dataprocServiceAccount(`value`: Output) {
        this.dataprocServiceAccount = value
    }

    /**
     * @param value An optional description of the instance.
     */
    @JvmName("iefxtbwxbhokrbaj")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value Display name for an instance.
     */
    @JvmName("ocmuwoflpgwfehgh")
    public suspend fun displayName(`value`: Output) {
        this.displayName = value
    }

    /**
     * @param value Option to enable granular role-based access control.
     */
    @JvmName("hcmpeucfkbgsxomb")
    public suspend fun enableRbac(`value`: Output) {
        this.enableRbac = value
    }

    /**
     * @param value Option to enable Stackdriver Logging.
     */
    @JvmName("mrvodniqisxpterr")
    public suspend fun enableStackdriverLogging(`value`: Output) {
        this.enableStackdriverLogging = value
    }

    /**
     * @param value Option to enable Stackdriver Monitoring.
     */
    @JvmName("lstlgmxwkvalcump")
    public suspend fun enableStackdriverMonitoring(`value`: Output) {
        this.enableStackdriverMonitoring = value
    }

    /**
     * @param value Option to enable and pass metadata for event publishing.
     * Structure is documented below.
     */
    @JvmName("ettgvlepyoneqooq")
    public suspend fun eventPublishConfig(`value`: Output) {
        this.eventPublishConfig = value
    }

    /**
     * @param value The resource labels for instance to use to annotate any related underlying resources,
     * such as Compute Engine VMs.
     * **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("fxtvpkgmqwlpcvte")
    public suspend fun labels(`value`: Output>) {
        this.labels = value
    }

    /**
     * @param value The ID of the instance or a fully qualified identifier for the instance.
     */
    @JvmName("febwesyphxdnonbv")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value Network configuration options. These are required when a private Data Fusion instance is to be created.
     * Structure is documented below.
     */
    @JvmName("rhavfitdtlwwdqde")
    public suspend fun networkConfig(`value`: Output) {
        this.networkConfig = value
    }

    /**
     * @param value Map of additional options used to configure the behavior of Data Fusion instance.
     */
    @JvmName("plvyspkdohymrqse")
    public suspend fun options(`value`: Output>) {
        this.options = value
    }

    /**
     * @param value Specifies whether the Data Fusion instance should be private. If set to
     * true, all Data Fusion nodes will have private IP addresses and will not be
     * able to access the public internet.
     */
    @JvmName("vfqdyfvmofgfvwgn")
    public suspend fun privateInstance(`value`: Output) {
        this.privateInstance = value
    }

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

    /**
     * @param value The region of the Data Fusion instance.
     */
    @JvmName("eweibiavdselorpa")
    public suspend fun region(`value`: Output) {
        this.region = value
    }

    /**
     * @param value Represents the type of Data Fusion instance. Each type is configured with
     * the default settings for processing and memory.
     * - BASIC: Basic Data Fusion instance. In Basic type, the user will be able to create data pipelines
     * using point and click UI. However, there are certain limitations, such as fewer number
     * of concurrent pipelines, no support for streaming pipelines, etc.
     * - ENTERPRISE: Enterprise Data Fusion instance. In Enterprise type, the user will have more features
     * available, such as support for streaming pipelines, higher number of concurrent pipelines, etc.
     * - DEVELOPER: Developer Data Fusion instance. In Developer type, the user will have all features available but
     * with restrictive capabilities. This is to help enterprises design and develop their data ingestion and integration
     * pipelines at low cost.
     * Possible values are: `BASIC`, `ENTERPRISE`, `DEVELOPER`.
     * - - -
     */
    @JvmName("ufvusauaqictuohh")
    public suspend fun type(`value`: Output) {
        this.type = value
    }

    /**
     * @param value Current version of the Data Fusion.
     */
    @JvmName("dlsxofgkktjtekdv")
    public suspend fun version(`value`: Output) {
        this.version = value
    }

    /**
     * @param value Name of the zone in which the Data Fusion instance will be created. Only DEVELOPER instances use this field.
     */
    @JvmName("dxpbpnkrjlfjnsfl")
    public suspend fun zone(`value`: Output) {
        this.zone = value
    }

    /**
     * @param value List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("goicdalimryrvvsl")
    public suspend fun accelerators(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.accelerators = mapped
    }

    /**
     * @param argument List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("nidvxndamavloopc")
    public suspend fun accelerators(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            InstanceAcceleratorArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.accelerators = mapped
    }

    /**
     * @param argument List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("rdvyjpwallysbtjg")
    public suspend fun accelerators(vararg argument: suspend InstanceAcceleratorArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            InstanceAcceleratorArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.accelerators = mapped
    }

    /**
     * @param argument List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("xyfdwprtnactkydr")
    public suspend fun accelerators(argument: suspend InstanceAcceleratorArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(InstanceAcceleratorArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.accelerators = mapped
    }

    /**
     * @param values List of accelerators enabled for this CDF instance.
     * If accelerators are enabled it is possible a permadiff will be created with the Options field.
     * Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
     * Structure is documented below.
     */
    @JvmName("aytlsayrvouckvrn")
    public suspend fun accelerators(vararg values: InstanceAcceleratorArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.accelerators = mapped
    }

    /**
     * @param value The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
     * Structure is documented below.
     */
    @JvmName("plapbuapyubblvkc")
    public suspend fun cryptoKeyConfig(`value`: InstanceCryptoKeyConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.cryptoKeyConfig = mapped
    }

    /**
     * @param argument The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
     * Structure is documented below.
     */
    @JvmName("swarkquhsrsrdamo")
    public suspend fun cryptoKeyConfig(argument: suspend InstanceCryptoKeyConfigArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceCryptoKeyConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.cryptoKeyConfig = mapped
    }

    /**
     * @param value User-managed service account to set on Dataproc when Cloud Data Fusion creates Dataproc to run data processing pipelines.
     */
    @JvmName("exeujaciaekshdpd")
    public suspend fun dataprocServiceAccount(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataprocServiceAccount = mapped
    }

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

    /**
     * @param value Display name for an instance.
     */
    @JvmName("cxwhbdvvkqfqltvm")
    public suspend fun displayName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.displayName = mapped
    }

    /**
     * @param value Option to enable granular role-based access control.
     */
    @JvmName("hqreopnhmaoxgcgw")
    public suspend fun enableRbac(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableRbac = mapped
    }

    /**
     * @param value Option to enable Stackdriver Logging.
     */
    @JvmName("hmygvqxjolubjamv")
    public suspend fun enableStackdriverLogging(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableStackdriverLogging = mapped
    }

    /**
     * @param value Option to enable Stackdriver Monitoring.
     */
    @JvmName("lmkmfysfqcrgxpun")
    public suspend fun enableStackdriverMonitoring(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableStackdriverMonitoring = mapped
    }

    /**
     * @param value Option to enable and pass metadata for event publishing.
     * Structure is documented below.
     */
    @JvmName("xjynfrhdlmfrsdob")
    public suspend fun eventPublishConfig(`value`: InstanceEventPublishConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.eventPublishConfig = mapped
    }

    /**
     * @param argument Option to enable and pass metadata for event publishing.
     * Structure is documented below.
     */
    @JvmName("rorvgyounvoddtfw")
    public suspend fun eventPublishConfig(argument: suspend InstanceEventPublishConfigArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceEventPublishConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.eventPublishConfig = mapped
    }

    /**
     * @param value The resource labels for instance to use to annotate any related underlying resources,
     * such as Compute Engine VMs.
     * **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("auwsrunauckoifhq")
    public suspend fun labels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param values The resource labels for instance to use to annotate any related underlying resources,
     * such as Compute Engine VMs.
     * **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("uontdekslrgfnqfk")
    public fun labels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param value The ID of the instance or a fully qualified identifier for the instance.
     */
    @JvmName("xelnlrresdqlpfju")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value Network configuration options. These are required when a private Data Fusion instance is to be created.
     * Structure is documented below.
     */
    @JvmName("dtprrhlxtqpoific")
    public suspend fun networkConfig(`value`: InstanceNetworkConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.networkConfig = mapped
    }

    /**
     * @param argument Network configuration options. These are required when a private Data Fusion instance is to be created.
     * Structure is documented below.
     */
    @JvmName("hnxxgbjcwbkmejao")
    public suspend fun networkConfig(argument: suspend InstanceNetworkConfigArgsBuilder.() -> Unit) {
        val toBeMapped = InstanceNetworkConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.networkConfig = mapped
    }

    /**
     * @param value Map of additional options used to configure the behavior of Data Fusion instance.
     */
    @JvmName("mjawrnnnpigphpjy")
    public suspend fun options(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.options = mapped
    }

    /**
     * @param values Map of additional options used to configure the behavior of Data Fusion instance.
     */
    @JvmName("cbpfjrjnqjtfwmup")
    public fun options(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.options = mapped
    }

    /**
     * @param value Specifies whether the Data Fusion instance should be private. If set to
     * true, all Data Fusion nodes will have private IP addresses and will not be
     * able to access the public internet.
     */
    @JvmName("sqtbcasbcykcftyn")
    public suspend fun privateInstance(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.privateInstance = mapped
    }

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

    /**
     * @param value The region of the Data Fusion instance.
     */
    @JvmName("dcolerqdkkfabdfd")
    public suspend fun region(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.region = mapped
    }

    /**
     * @param value Represents the type of Data Fusion instance. Each type is configured with
     * the default settings for processing and memory.
     * - BASIC: Basic Data Fusion instance. In Basic type, the user will be able to create data pipelines
     * using point and click UI. However, there are certain limitations, such as fewer number
     * of concurrent pipelines, no support for streaming pipelines, etc.
     * - ENTERPRISE: Enterprise Data Fusion instance. In Enterprise type, the user will have more features
     * available, such as support for streaming pipelines, higher number of concurrent pipelines, etc.
     * - DEVELOPER: Developer Data Fusion instance. In Developer type, the user will have all features available but
     * with restrictive capabilities. This is to help enterprises design and develop their data ingestion and integration
     * pipelines at low cost.
     * Possible values are: `BASIC`, `ENTERPRISE`, `DEVELOPER`.
     * - - -
     */
    @JvmName("rjwxvpvxftsmaymg")
    public suspend fun type(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.type = mapped
    }

    /**
     * @param value Current version of the Data Fusion.
     */
    @JvmName("oaetwabvudbnclew")
    public suspend fun version(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.version = mapped
    }

    /**
     * @param value Name of the zone in which the Data Fusion instance will be created. Only DEVELOPER instances use this field.
     */
    @JvmName("nppmdfwqeiojgegs")
    public suspend fun zone(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.zone = mapped
    }

    internal fun build(): InstanceArgs = InstanceArgs(
        accelerators = accelerators,
        cryptoKeyConfig = cryptoKeyConfig,
        dataprocServiceAccount = dataprocServiceAccount,
        description = description,
        displayName = displayName,
        enableRbac = enableRbac,
        enableStackdriverLogging = enableStackdriverLogging,
        enableStackdriverMonitoring = enableStackdriverMonitoring,
        eventPublishConfig = eventPublishConfig,
        labels = labels,
        name = name,
        networkConfig = networkConfig,
        options = options,
        privateInstance = privateInstance,
        project = project,
        region = region,
        type = type,
        version = version,
        zone = zone,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy