pulumi-gcp-kotlin/com.pulumi.gcp.datafusion.kotlin/Instance

Instance

class Instance : KotlinCustomResource

Represents a Data Fusion instance. To get more information about Instance, see:

Example Usage

Data Fusion Instance Basic

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()
            .region("us-central1")
            .type("BASIC")
            .build());
    }
}
Content copied to clipboard

Data Fusion Instance Full

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.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");
        var privateIpAlloc = new GlobalAddress("privateIpAlloc", GlobalAddressArgs.builder()
            .addressType("INTERNAL")
            .purpose("VPC_PEERING")
            .prefixLength(22)
            .network(network.id())
            .build());
        var extendedInstance = new Instance("extendedInstance", InstanceArgs.builder()
            .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());
    }
}
Content copied to clipboard

Data Fusion Instance Cmek

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.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.kms.CryptoKeyIAMBinding;
import com.pulumi.gcp.kms.CryptoKeyIAMBindingArgs;
import com.pulumi.gcp.datafusion.Instance;
import com.pulumi.gcp.datafusion.InstanceArgs;
import com.pulumi.gcp.datafusion.inputs.InstanceCryptoKeyConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
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()
            .location("us-central1")
            .build());
        var cryptoKey = new CryptoKey("cryptoKey", CryptoKeyArgs.builder()
            .keyRing(keyRing.id())
            .build());
        final var project = OrganizationsFunctions.getProject();
        var cryptoKeyBinding = new CryptoKeyIAMBinding("cryptoKeyBinding", CryptoKeyIAMBindingArgs.builder()
            .cryptoKeyId(cryptoKey.id())
            .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
            .members(String.format("serviceAccount:service-%s@gcp-sa-datafusion.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
            .build());
        var cmek = new Instance("cmek", InstanceArgs.builder()
            .region("us-central1")
            .type("BASIC")
            .cryptoKeyConfig(InstanceCryptoKeyConfigArgs.builder()
                .keyReference(cryptoKey.id())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(cryptoKeyBinding)
                .build());
    }
}
Content copied to clipboard

Data Fusion Instance Enterprise

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()
            .enableRbac(true)
            .region("us-central1")
            .type("ENTERPRISE")
            .build());
    }
}
Content copied to clipboard

Data Fusion Instance Event

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.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");
        var eventInstance = new Instance("eventInstance", InstanceArgs.builder()
            .region("us-central1")
            .type("BASIC")
            .eventPublishConfig(InstanceEventPublishConfigArgs.builder()
                .enabled(true)
                .topic(eventTopic.id())
                .build())
            .build());
    }
}
Content copied to clipboard

Data Fusion Instance Zone

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()
            .region("us-central1")
            .type("DEVELOPER")
            .zone("us-central1-a")
            .build());
    }
}
Content copied to clipboard

Import

Instance can be imported using any of these accepted formats

$ pulumi import gcp:datafusion/instance:Instance default projects/{{project}}/locations/{{region}}/instances/{{name}}
Content copied to clipboard
$ pulumi import gcp:datafusion/instance:Instance default {{project}}/{{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:datafusion/instance:Instance default {{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:datafusion/instance:Instance default {{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val accelerators: Output<List<InstanceAccelerator>>?

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

Link copied to clipboard
val apiEndpoint: Output<String>

Endpoint on which the REST APIs is accessible.

Link copied to clipboard
val createTime: Output<String>

The time the instance was created in RFC3339 UTC "Zulu" format, accurate to nanoseconds.

Link copied to clipboard
val cryptoKeyConfig: Output<InstanceCryptoKeyConfig>?

The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature. Structure is documented below.

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

User-managed service account to set on Dataproc when Cloud Data Fusion creates Dataproc to run data processing pipelines.

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

An optional description of the instance.

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

Display name for an instance.

Link copied to clipboard
val enableRbac: Output<Boolean>?

Option to enable granular role-based access control.

Link copied to clipboard
val enableStackdriverLogging: Output<Boolean>?

Option to enable Stackdriver Logging.

Link copied to clipboard
val enableStackdriverMonitoring: Output<Boolean>?

Option to enable Stackdriver Monitoring.

Link copied to clipboard
val eventPublishConfig: Output<InstanceEventPublishConfig>?

Option to enable and pass metadata for event publishing. Structure is documented below.

Link copied to clipboard
val gcsBucket: Output<String>

Cloud Storage bucket generated by Data Fusion in the customer project.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

The resource labels for instance to use to annotate any related underlying resources, such as Compute Engine VMs.

Link copied to clipboard
val name: Output<String>

The ID of the instance or a fully qualified identifier for the instance.

Link copied to clipboard
val networkConfig: Output<InstanceNetworkConfig>?

Network configuration options. These are required when a private Data Fusion instance is to be created. Structure is documented below.

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

Map of additional options used to configure the behavior of Data Fusion instance.

Link copied to clipboard
val p4ServiceAccount: Output<String>

P4 service account for the customer project.

Link copied to clipboard
val privateInstance: Output<Boolean>?

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.

Link copied to clipboard
val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val region: Output<String>

The region of the Data Fusion instance.

Link copied to clipboard
val serviceAccount: Output<String>

Service account which will be used to access resources in the customer project.

Link copied to clipboard
val serviceEndpoint: Output<String>

Endpoint on which the Data Fusion UI and REST APIs are accessible.

Link copied to clipboard
val state: Output<String>

The type of an accelator for a CDF instance. Possible values are: ENABLED, DISABLED.

Link copied to clipboard
val stateMessage: Output<String>

Additional information about the current state of this Data Fusion instance if available.

Link copied to clipboard
val tenantProjectId: Output<String>

The name of the tenant project.

Link copied to clipboard
val type: Output<String>

Represents the type of Data Fusion instance. Each type is configured with the default settings for processing and memory.

Link copied to clipboard
val updateTime: Output<String>

The time the instance was last updated in RFC3339 UTC "Zulu" format, accurate to nanoseconds.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val version: Output<String>

Current version of the Data Fusion.

Link copied to clipboard
val zone: Output<String>

Name of the zone in which the Data Fusion instance will be created. Only DEVELOPER instances use this field.