com.pulumi.gcp.dataplex.kotlin.Asset.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-gcp-kotlin Show documentation
Show all versions of pulumi-gcp-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.gcp.dataplex.kotlin
import com.pulumi.core.Output
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetDiscoverySpec
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetDiscoveryStatus
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetResourceSpec
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetResourceStatus
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetSecurityStatus
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Any
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetDiscoverySpec.Companion.toKotlin as assetDiscoverySpecToKotlin
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetDiscoveryStatus.Companion.toKotlin as assetDiscoveryStatusToKotlin
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetResourceSpec.Companion.toKotlin as assetResourceSpecToKotlin
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetResourceStatus.Companion.toKotlin as assetResourceStatusToKotlin
import com.pulumi.gcp.dataplex.kotlin.outputs.AssetSecurityStatus.Companion.toKotlin as assetSecurityStatusToKotlin
/**
* Builder for [Asset].
*/
@PulumiTagMarker
public class AssetResourceBuilder internal constructor() {
public var name: String? = null
public var args: AssetArgs = AssetArgs()
public var opts: CustomResourceOptions = CustomResourceOptions()
/**
* @param name The _unique_ name of the resulting resource.
*/
public fun name(`value`: String) {
this.name = value
}
/**
* @param block The arguments to use to populate this resource's properties.
*/
public suspend fun args(block: suspend AssetArgsBuilder.() -> Unit) {
val builder = AssetArgsBuilder()
block(builder)
this.args = builder.build()
}
/**
* @param block A bag of options that control this resource's behavior.
*/
public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
}
internal fun build(): Asset {
val builtJavaResource = com.pulumi.gcp.dataplex.Asset(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return Asset(builtJavaResource)
}
}
/**
* The Dataplex Asset resource
* ## Example Usage
* ### Basic_asset
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const basicBucket = new gcp.storage.Bucket("basic_bucket", {
* name: "bucket",
* location: "us-west1",
* uniformBucketLevelAccess: true,
* project: "my-project-name",
* });
* const basicLake = new gcp.dataplex.Lake("basic_lake", {
* name: "lake",
* location: "us-west1",
* project: "my-project-name",
* });
* const basicZone = new gcp.dataplex.Zone("basic_zone", {
* name: "zone",
* location: "us-west1",
* lake: basicLake.name,
* type: "RAW",
* discoverySpec: {
* enabled: false,
* },
* resourceSpec: {
* locationType: "SINGLE_REGION",
* },
* project: "my-project-name",
* });
* const primary = new gcp.dataplex.Asset("primary", {
* name: "asset",
* location: "us-west1",
* lake: basicLake.name,
* dataplexZone: basicZone.name,
* discoverySpec: {
* enabled: false,
* },
* resourceSpec: {
* name: "projects/my-project-name/buckets/bucket",
* type: "STORAGE_BUCKET",
* },
* labels: {
* env: "foo",
* "my-asset": "exists",
* },
* project: "my-project-name",
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* basic_bucket = gcp.storage.Bucket("basic_bucket",
* name="bucket",
* location="us-west1",
* uniform_bucket_level_access=True,
* project="my-project-name")
* basic_lake = gcp.dataplex.Lake("basic_lake",
* name="lake",
* location="us-west1",
* project="my-project-name")
* basic_zone = gcp.dataplex.Zone("basic_zone",
* name="zone",
* location="us-west1",
* lake=basic_lake.name,
* type="RAW",
* discovery_spec=gcp.dataplex.ZoneDiscoverySpecArgs(
* enabled=False,
* ),
* resource_spec=gcp.dataplex.ZoneResourceSpecArgs(
* location_type="SINGLE_REGION",
* ),
* project="my-project-name")
* primary = gcp.dataplex.Asset("primary",
* name="asset",
* location="us-west1",
* lake=basic_lake.name,
* dataplex_zone=basic_zone.name,
* discovery_spec=gcp.dataplex.AssetDiscoverySpecArgs(
* enabled=False,
* ),
* resource_spec=gcp.dataplex.AssetResourceSpecArgs(
* name="projects/my-project-name/buckets/bucket",
* type="STORAGE_BUCKET",
* ),
* labels={
* "env": "foo",
* "my-asset": "exists",
* },
* project="my-project-name")
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var basicBucket = new Gcp.Storage.Bucket("basic_bucket", new()
* {
* Name = "bucket",
* Location = "us-west1",
* UniformBucketLevelAccess = true,
* Project = "my-project-name",
* });
* var basicLake = new Gcp.DataPlex.Lake("basic_lake", new()
* {
* Name = "lake",
* Location = "us-west1",
* Project = "my-project-name",
* });
* var basicZone = new Gcp.DataPlex.Zone("basic_zone", new()
* {
* Name = "zone",
* Location = "us-west1",
* Lake = basicLake.Name,
* Type = "RAW",
* DiscoverySpec = new Gcp.DataPlex.Inputs.ZoneDiscoverySpecArgs
* {
* Enabled = false,
* },
* ResourceSpec = new Gcp.DataPlex.Inputs.ZoneResourceSpecArgs
* {
* LocationType = "SINGLE_REGION",
* },
* Project = "my-project-name",
* });
* var primary = new Gcp.DataPlex.Asset("primary", new()
* {
* Name = "asset",
* Location = "us-west1",
* Lake = basicLake.Name,
* DataplexZone = basicZone.Name,
* DiscoverySpec = new Gcp.DataPlex.Inputs.AssetDiscoverySpecArgs
* {
* Enabled = false,
* },
* ResourceSpec = new Gcp.DataPlex.Inputs.AssetResourceSpecArgs
* {
* Name = "projects/my-project-name/buckets/bucket",
* Type = "STORAGE_BUCKET",
* },
* Labels =
* {
* { "env", "foo" },
* { "my-asset", "exists" },
* },
* Project = "my-project-name",
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/dataplex"
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/storage"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* _, err := storage.NewBucket(ctx, "basic_bucket", &storage.BucketArgs{
* Name: pulumi.String("bucket"),
* Location: pulumi.String("us-west1"),
* UniformBucketLevelAccess: pulumi.Bool(true),
* Project: pulumi.String("my-project-name"),
* })
* if err != nil {
* return err
* }
* basicLake, err := dataplex.NewLake(ctx, "basic_lake", &dataplex.LakeArgs{
* Name: pulumi.String("lake"),
* Location: pulumi.String("us-west1"),
* Project: pulumi.String("my-project-name"),
* })
* if err != nil {
* return err
* }
* basicZone, err := dataplex.NewZone(ctx, "basic_zone", &dataplex.ZoneArgs{
* Name: pulumi.String("zone"),
* Location: pulumi.String("us-west1"),
* Lake: basicLake.Name,
* Type: pulumi.String("RAW"),
* DiscoverySpec: &dataplex.ZoneDiscoverySpecArgs{
* Enabled: pulumi.Bool(false),
* },
* ResourceSpec: &dataplex.ZoneResourceSpecArgs{
* LocationType: pulumi.String("SINGLE_REGION"),
* },
* Project: pulumi.String("my-project-name"),
* })
* if err != nil {
* return err
* }
* _, err = dataplex.NewAsset(ctx, "primary", &dataplex.AssetArgs{
* Name: pulumi.String("asset"),
* Location: pulumi.String("us-west1"),
* Lake: basicLake.Name,
* DataplexZone: basicZone.Name,
* DiscoverySpec: &dataplex.AssetDiscoverySpecArgs{
* Enabled: pulumi.Bool(false),
* },
* ResourceSpec: &dataplex.AssetResourceSpecArgs{
* Name: pulumi.String("projects/my-project-name/buckets/bucket"),
* Type: pulumi.String("STORAGE_BUCKET"),
* },
* Labels: pulumi.StringMap{
* "env": pulumi.String("foo"),
* "my-asset": pulumi.String("exists"),
* },
* Project: pulumi.String("my-project-name"),
* })
* 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.storage.Bucket;
* import com.pulumi.gcp.storage.BucketArgs;
* import com.pulumi.gcp.dataplex.Lake;
* import com.pulumi.gcp.dataplex.LakeArgs;
* import com.pulumi.gcp.dataplex.Zone;
* import com.pulumi.gcp.dataplex.ZoneArgs;
* import com.pulumi.gcp.dataplex.inputs.ZoneDiscoverySpecArgs;
* import com.pulumi.gcp.dataplex.inputs.ZoneResourceSpecArgs;
* import com.pulumi.gcp.dataplex.Asset;
* import com.pulumi.gcp.dataplex.AssetArgs;
* import com.pulumi.gcp.dataplex.inputs.AssetDiscoverySpecArgs;
* import com.pulumi.gcp.dataplex.inputs.AssetResourceSpecArgs;
* 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 basicBucket = new Bucket("basicBucket", BucketArgs.builder()
* .name("bucket")
* .location("us-west1")
* .uniformBucketLevelAccess(true)
* .project("my-project-name")
* .build());
* var basicLake = new Lake("basicLake", LakeArgs.builder()
* .name("lake")
* .location("us-west1")
* .project("my-project-name")
* .build());
* var basicZone = new Zone("basicZone", ZoneArgs.builder()
* .name("zone")
* .location("us-west1")
* .lake(basicLake.name())
* .type("RAW")
* .discoverySpec(ZoneDiscoverySpecArgs.builder()
* .enabled(false)
* .build())
* .resourceSpec(ZoneResourceSpecArgs.builder()
* .locationType("SINGLE_REGION")
* .build())
* .project("my-project-name")
* .build());
* var primary = new Asset("primary", AssetArgs.builder()
* .name("asset")
* .location("us-west1")
* .lake(basicLake.name())
* .dataplexZone(basicZone.name())
* .discoverySpec(AssetDiscoverySpecArgs.builder()
* .enabled(false)
* .build())
* .resourceSpec(AssetResourceSpecArgs.builder()
* .name("projects/my-project-name/buckets/bucket")
* .type("STORAGE_BUCKET")
* .build())
* .labels(Map.ofEntries(
* Map.entry("env", "foo"),
* Map.entry("my-asset", "exists")
* ))
* .project("my-project-name")
* .build());
* }
* }
* ```
* ```yaml
* resources:
* basicBucket:
* type: gcp:storage:Bucket
* name: basic_bucket
* properties:
* name: bucket
* location: us-west1
* uniformBucketLevelAccess: true
* project: my-project-name
* basicLake:
* type: gcp:dataplex:Lake
* name: basic_lake
* properties:
* name: lake
* location: us-west1
* project: my-project-name
* basicZone:
* type: gcp:dataplex:Zone
* name: basic_zone
* properties:
* name: zone
* location: us-west1
* lake: ${basicLake.name}
* type: RAW
* discoverySpec:
* enabled: false
* resourceSpec:
* locationType: SINGLE_REGION
* project: my-project-name
* primary:
* type: gcp:dataplex:Asset
* properties:
* name: asset
* location: us-west1
* lake: ${basicLake.name}
* dataplexZone: ${basicZone.name}
* discoverySpec:
* enabled: false
* resourceSpec:
* name: projects/my-project-name/buckets/bucket
* type: STORAGE_BUCKET
* labels:
* env: foo
* my-asset: exists
* project: my-project-name
* ```
*
* ## Import
* Asset can be imported using any of these accepted formats:
* * `projects/{{project}}/locations/{{location}}/lakes/{{lake}}/zones/{{dataplex_zone}}/assets/{{name}}`
* * `{{project}}/{{location}}/{{lake}}/{{dataplex_zone}}/{{name}}`
* * `{{location}}/{{lake}}/{{dataplex_zone}}/{{name}}`
* When using the `pulumi import` command, Asset can be imported using one of the formats above. For example:
* ```sh
* $ pulumi import gcp:dataplex/asset:Asset default projects/{{project}}/locations/{{location}}/lakes/{{lake}}/zones/{{dataplex_zone}}/assets/{{name}}
* ```
* ```sh
* $ pulumi import gcp:dataplex/asset:Asset default {{project}}/{{location}}/{{lake}}/{{dataplex_zone}}/{{name}}
* ```
* ```sh
* $ pulumi import gcp:dataplex/asset:Asset default {{location}}/{{lake}}/{{dataplex_zone}}/{{name}}
* ```
*/
public class Asset internal constructor(
override val javaResource: com.pulumi.gcp.dataplex.Asset,
) : KotlinCustomResource(javaResource, AssetMapper) {
/**
* Output only. The time when the asset was created.
*/
public val createTime: Output
get() = javaResource.createTime().applyValue({ args0 -> args0 })
/**
* The zone for the resource
*/
public val dataplexZone: Output
get() = javaResource.dataplexZone().applyValue({ args0 -> args0 })
/**
* Optional. Description of the asset.
*/
public val description: Output?
get() = javaResource.description().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Required. Specification of the discovery feature applied to data referenced by this asset. When this spec is left unset, the asset will use the spec set on the parent zone.
*/
public val discoverySpec: Output
get() = javaResource.discoverySpec().applyValue({ args0 ->
args0.let({ args0 ->
assetDiscoverySpecToKotlin(args0)
})
})
/**
* Output only. Status of the discovery feature applied to data referenced by this asset.
*/
public val discoveryStatuses: Output>
get() = javaResource.discoveryStatuses().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> assetDiscoveryStatusToKotlin(args0) })
})
})
/**
* Optional. User friendly display name.
*/
public val displayName: Output?
get() = javaResource.displayName().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
*/
public val effectiveLabels: Output>
get() = javaResource.effectiveLabels().applyValue({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
})
/**
* Optional. User defined labels for the asset. **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.
*/
public val labels: Output>?
get() = javaResource.labels().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
}).orElse(null)
})
/**
* The lake for the resource
*/
public val lake: Output
get() = javaResource.lake().applyValue({ args0 -> args0 })
/**
* The location for the resource
*/
public val location: Output
get() = javaResource.location().applyValue({ args0 -> args0 })
/**
* The name of the asset.
*/
public val name: Output
get() = javaResource.name().applyValue({ args0 -> args0 })
/**
* The project for the resource
*/
public val project: Output
get() = javaResource.project().applyValue({ args0 -> args0 })
/**
* The combination of labels configured directly on the resource and default labels configured on the provider.
*/
public val pulumiLabels: Output>
get() = javaResource.pulumiLabels().applyValue({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
})
/**
* Required. Immutable. Specification of the resource that is referenced by this asset.
*/
public val resourceSpec: Output
get() = javaResource.resourceSpec().applyValue({ args0 ->
args0.let({ args0 ->
assetResourceSpecToKotlin(args0)
})
})
/**
* Output only. Status of the resource referenced by this asset.
*/
public val resourceStatuses: Output>
get() = javaResource.resourceStatuses().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> assetResourceStatusToKotlin(args0) })
})
})
/**
* Output only. Status of the security policy applied to resource referenced by this asset.
*/
public val securityStatuses: Output>
get() = javaResource.securityStatuses().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> assetSecurityStatusToKotlin(args0) })
})
})
/**
* Output only. Current state of the asset. Possible values: STATE_UNSPECIFIED, ACTIVE, CREATING, DELETING, ACTION_REQUIRED
*/
public val state: Output
get() = javaResource.state().applyValue({ args0 -> args0 })
/**
* Output only. System generated globally unique ID for the asset. This ID will be different if the asset is deleted and re-created with the same name.
*/
public val uid: Output
get() = javaResource.uid().applyValue({ args0 -> args0 })
/**
* Output only. The time when the asset was last updated.
*/
public val updateTime: Output
get() = javaResource.updateTime().applyValue({ args0 -> args0 })
}
public object AssetMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.gcp.dataplex.Asset::class == javaResource::class
override fun map(javaResource: Resource): Asset = Asset(
javaResource as
com.pulumi.gcp.dataplex.Asset,
)
}
/**
* @see [Asset].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [Asset].
*/
public suspend fun asset(name: String, block: suspend AssetResourceBuilder.() -> Unit): Asset {
val builder = AssetResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [Asset].
* @param name The _unique_ name of the resulting resource.
*/
public fun asset(name: String): Asset {
val builder = AssetResourceBuilder()
builder.name(name)
return builder.build()
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy