DataExchangeSubscription class

A Bigquery Analytics Hub Data Exchange subscription

> Warning: This resource is in beta, and should be used with the terraform-provider-google-beta provider. See Provider Versions for more details on beta resources.

To get more information about DataExchangeSubscription, see:

• API documentation
• How-to Guides
• Official Documentation

> Note: When importing the resource with pulumi import, provide the destination/subscriber's project and location in the format projects/{{subscriber_project}}/locations/{{subscriber_location}}/subscriptions/{{subscription_id}}

Example Usage

Bigquery Analyticshub Dataexchange Subscription Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const subscription = new gcp.bigqueryanalyticshub.DataExchange("subscription", {
    location: "us",
    dataExchangeId: "my_test_dataexchange",
    displayName: "my_test_dataexchange",
    description: "Test Data Exchange",
    sharingEnvironmentConfig: {
        dcrExchangeConfig: {},
    },
});
const subscriptionDataset = new gcp.bigquery.Dataset("subscription", {
    datasetId: "listing_src_dataset",
    friendlyName: "listing_src_dataset",
    description: "Dataset for Listing",
    location: "us",
});
const subscriptionTable = new gcp.bigquery.Table("subscription", {
    deletionProtection: false,
    tableId: "listing_src_table",
    datasetId: subscriptionDataset.datasetId,
    schema: `[
  {
    \\"name\\": \\"name\\",
    \\"type\\": \\"STRING\\",
    \\"mode\\": \\"NULLABLE\\"
  },
  {
    \\"name\\": \\"post_abbr\\",
    \\"type\\": \\"STRING\\",
    \\"mode\\": \\"NULLABLE\\"
  },
  {
    \\"name\\": \\"date\\",
    \\"type\\": \\"DATE\\",
    \\"mode\\": \\"NULLABLE\\"
  }
]
`,
});
const subscriptionListing = new gcp.bigqueryanalyticshub.Listing("subscription", {
    location: "us",
    dataExchangeId: subscription.dataExchangeId,
    listingId: "my_test_listing",
    displayName: "my_test_listing",
    description: "Test Listing",
    restrictedExportConfig: {
        enabled: true,
    },
    bigqueryDataset: {
        dataset: subscriptionDataset.id,
        selectedResources: [{
            table: subscriptionTable.id,
        }],
    },
});
const subscriptionDataExchangeSubscription = new gcp.bigqueryanalyticshub.DataExchangeSubscription("subscription", {
    project: subscriptionDataset.project,
    location: "us",
    dataExchangeProject: subscription.project,
    dataExchangeLocation: subscription.location,
    dataExchangeId: subscription.dataExchangeId,
    subscriptionId: "my_subscription_id",
    subscriberContact: "[e-mail]",
    destinationDataset: {
        location: "us",
        datasetReference: {
            projectId: subscriptionDataset.project,
            datasetId: "subscribed_dest_dataset",
        },
        friendlyName: "Subscribed Destination Dataset",
        description: "Destination dataset for subscription",
        labels: {
            environment: "development",
            owner: "team-a",
        },
    },
    refreshPolicy: "ON_READ",
});

import pulumi
import pulumi_gcp as gcp

subscription = gcp.bigqueryanalyticshub.DataExchange("subscription",
    location="us",
    data_exchange_id="my_test_dataexchange",
    display_name="my_test_dataexchange",
    description="Test Data Exchange",
    sharing_environment_config={
        "dcr_exchange_config": {},
    })
subscription_dataset = gcp.bigquery.Dataset("subscription",
    dataset_id="listing_src_dataset",
    friendly_name="listing_src_dataset",
    description="Dataset for Listing",
    location="us")
subscription_table = gcp.bigquery.Table("subscription",
    deletion_protection=False,
    table_id="listing_src_table",
    dataset_id=subscription_dataset.dataset_id,
    schema="""[
  {
    \"name\": \"name\",
    \"type\": \"STRING\",
    \"mode\": \"NULLABLE\"
  },
  {
    \"name\": \"post_abbr\",
    \"type\": \"STRING\",
    \"mode\": \"NULLABLE\"
  },
  {
    \"name\": \"date\",
    \"type\": \"DATE\",
    \"mode\": \"NULLABLE\"
  }
]
""")
subscription_listing = gcp.bigqueryanalyticshub.Listing("subscription",
    location="us",
    data_exchange_id=subscription.data_exchange_id,
    listing_id="my_test_listing",
    display_name="my_test_listing",
    description="Test Listing",
    restricted_export_config={
        "enabled": True,
    },
    bigquery_dataset={
        "dataset": subscription_dataset.id,
        "selected_resources": [{
            "table": subscription_table.id,
        }],
    })
subscription_data_exchange_subscription = gcp.bigqueryanalyticshub.DataExchangeSubscription("subscription",
    project=subscription_dataset.project,
    location="us",
    data_exchange_project=subscription.project,
    data_exchange_location=subscription.location,
    data_exchange_id=subscription.data_exchange_id,
    subscription_id="my_subscription_id",
    subscriber_contact="[e-mail]",
    destination_dataset={
        "location": "us",
        "dataset_reference": {
            "project_id": subscription_dataset.project,
            "dataset_id": "subscribed_dest_dataset",
        },
        "friendly_name": "Subscribed Destination Dataset",
        "description": "Destination dataset for subscription",
        "labels": {
            "environment": "development",
            "owner": "team-a",
        },
    },
    refresh_policy="ON_READ")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var subscription = new Gcp.BigQueryAnalyticsHub.DataExchange("subscription", new()
    {
        Location = "us",
        DataExchangeId = "my_test_dataexchange",
        DisplayName = "my_test_dataexchange",
        Description = "Test Data Exchange",
        SharingEnvironmentConfig = new Gcp.BigQueryAnalyticsHub.Inputs.DataExchangeSharingEnvironmentConfigArgs
        {
            DcrExchangeConfig = null,
        },
    });

    var subscriptionDataset = new Gcp.BigQuery.Dataset("subscription", new()
    {
        DatasetId = "listing_src_dataset",
        FriendlyName = "listing_src_dataset",
        Description = "Dataset for Listing",
        Location = "us",
    });

    var subscriptionTable = new Gcp.BigQuery.Table("subscription", new()
    {
        DeletionProtection = false,
        TableId = "listing_src_table",
        DatasetId = subscriptionDataset.DatasetId,
        Schema = @"[
  {
    \""name\"": \""name\"",
    \""type\"": \""STRING\"",
    \""mode\"": \""NULLABLE\""
  },
  {
    \""name\"": \""post_abbr\"",
    \""type\"": \""STRING\"",
    \""mode\"": \""NULLABLE\""
  },
  {
    \""name\"": \""date\"",
    \""type\"": \""DATE\"",
    \""mode\"": \""NULLABLE\""
  }
]
",
    });

    var subscriptionListing = new Gcp.BigQueryAnalyticsHub.Listing("subscription", new()
    {
        Location = "us",
        DataExchangeId = subscription.DataExchangeId,
        ListingId = "my_test_listing",
        DisplayName = "my_test_listing",
        Description = "Test Listing",
        RestrictedExportConfig = new Gcp.BigQueryAnalyticsHub.Inputs.ListingRestrictedExportConfigArgs
        {
            Enabled = true,
        },
        BigqueryDataset = new Gcp.BigQueryAnalyticsHub.Inputs.ListingBigqueryDatasetArgs
        {
            Dataset = subscriptionDataset.Id,
            SelectedResources = new[]
            {
                new Gcp.BigQueryAnalyticsHub.Inputs.ListingBigqueryDatasetSelectedResourceArgs
                {
                    Table = subscriptionTable.Id,
                },
            },
        },
    });

    var subscriptionDataExchangeSubscription = new Gcp.BigQueryAnalyticsHub.DataExchangeSubscription("subscription", new()
    {
        Project = subscriptionDataset.Project,
        Location = "us",
        DataExchangeProject = subscription.Project,
        DataExchangeLocation = subscription.Location,
        DataExchangeId = subscription.DataExchangeId,
        SubscriptionId = "my_subscription_id",
        SubscriberContact = "[e-mail]",
        DestinationDataset = new Gcp.BigQueryAnalyticsHub.Inputs.DataExchangeSubscriptionDestinationDatasetArgs
        {
            Location = "us",
            DatasetReference = new Gcp.BigQueryAnalyticsHub.Inputs.DataExchangeSubscriptionDestinationDatasetDatasetReferenceArgs
            {
                ProjectId = subscriptionDataset.Project,
                DatasetId = "subscribed_dest_dataset",
            },
            FriendlyName = "Subscribed Destination Dataset",
            Description = "Destination dataset for subscription",
            Labels =
            {
                { "environment", "development" },
                { "owner", "team-a" },
            },
        },
        RefreshPolicy = "ON_READ",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/bigquery"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/bigqueryanalyticshub"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		subscription, err := bigqueryanalyticshub.NewDataExchange(ctx, "subscription", &bigqueryanalyticshub.DataExchangeArgs{
			Location:       pulumi.String("us"),
			DataExchangeId: pulumi.String("my_test_dataexchange"),
			DisplayName:    pulumi.String("my_test_dataexchange"),
			Description:    pulumi.String("Test Data Exchange"),
			SharingEnvironmentConfig: &bigqueryanalyticshub.DataExchangeSharingEnvironmentConfigArgs{
				DcrExchangeConfig: &bigqueryanalyticshub.DataExchangeSharingEnvironmentConfigDcrExchangeConfigArgs{},
			},
		})
		if err != nil {
			return err
		}
		subscriptionDataset, err := bigquery.NewDataset(ctx, "subscription", &bigquery.DatasetArgs{
			DatasetId:    pulumi.String("listing_src_dataset"),
			FriendlyName: pulumi.String("listing_src_dataset"),
			Description:  pulumi.String("Dataset for Listing"),
			Location:     pulumi.String("us"),
		})
		if err != nil {
			return err
		}
		subscriptionTable, err := bigquery.NewTable(ctx, "subscription", &bigquery.TableArgs{
			DeletionProtection: pulumi.Bool(false),
			TableId:            pulumi.String("listing_src_table"),
			DatasetId:          subscriptionDataset.DatasetId,
			Schema: pulumi.String(`[
  {
    \"name\": \"name\",
    \"type\": \"STRING\",
    \"mode\": \"NULLABLE\"
  },
  {
    \"name\": \"post_abbr\",
    \"type\": \"STRING\",
    \"mode\": \"NULLABLE\"
  },
  {
    \"name\": \"date\",
    \"type\": \"DATE\",
    \"mode\": \"NULLABLE\"
  }
]
`),
		})
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListing(ctx, "subscription", &bigqueryanalyticshub.ListingArgs{
			Location:       pulumi.String("us"),
			DataExchangeId: subscription.DataExchangeId,
			ListingId:      pulumi.String("my_test_listing"),
			DisplayName:    pulumi.String("my_test_listing"),
			Description:    pulumi.String("Test Listing"),
			RestrictedExportConfig: &bigqueryanalyticshub.ListingRestrictedExportConfigArgs{
				Enabled: pulumi.Bool(true),
			},
			BigqueryDataset: &bigqueryanalyticshub.ListingBigqueryDatasetArgs{
				Dataset: subscriptionDataset.ID().ToIDOutput().ToStringOutput(),
				SelectedResources: bigqueryanalyticshub.ListingBigqueryDatasetSelectedResourceArray{
					&bigqueryanalyticshub.ListingBigqueryDatasetSelectedResourceArgs{
						Table: subscriptionTable.ID().ToIDOutput().ToStringOutput(),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeSubscription(ctx, "subscription", &bigqueryanalyticshub.DataExchangeSubscriptionArgs{
			Project:              subscriptionDataset.Project,
			Location:             pulumi.String("us"),
			DataExchangeProject:  subscription.Project,
			DataExchangeLocation: subscription.Location,
			DataExchangeId:       subscription.DataExchangeId,
			SubscriptionId:       pulumi.String("my_subscription_id"),
			SubscriberContact:    pulumi.String("[e-mail]"),
			DestinationDataset: &bigqueryanalyticshub.DataExchangeSubscriptionDestinationDatasetArgs{
				Location: pulumi.String("us"),
				DatasetReference: &bigqueryanalyticshub.DataExchangeSubscriptionDestinationDatasetDatasetReferenceArgs{
					ProjectId: subscriptionDataset.Project,
					DatasetId: pulumi.String("subscribed_dest_dataset"),
				},
				FriendlyName: pulumi.String("Subscribed Destination Dataset"),
				Description:  pulumi.String("Destination dataset for subscription"),
				Labels: pulumi.StringMap{
					"environment": pulumi.String("development"),
					"owner":       pulumi.String("team-a"),
				},
			},
			RefreshPolicy: pulumi.String("ON_READ"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_bigqueryanalyticshub_dataexchange" "subscription" {
  location         = "us"
  data_exchange_id = "my_test_dataexchange"
  display_name     = "my_test_dataexchange"
  description      = "Test Data Exchange"
  sharing_environment_config = {
    dcr_exchange_config = {}
  }
}
resource "gcp_bigquery_dataset" "subscription" {
  dataset_id    = "listing_src_dataset"
  friendly_name = "listing_src_dataset"
  description   = "Dataset for Listing"
  location      = "us"
}
resource "gcp_bigquery_table" "subscription" {
  deletion_protection = false
  table_id            = "listing_src_table"
  dataset_id          = gcp_bigquery_dataset.subscription.dataset_id
  schema              = "[\n  {\n    \\\"name\\\": \\\"name\\\",\n    \\\"type\\\": \\\"STRING\\\",\n    \\\"mode\\\": \\\"NULLABLE\\\"\n  },\n  {\n    \\\"name\\\": \\\"post_abbr\\\",\n    \\\"type\\\": \\\"STRING\\\",\n    \\\"mode\\\": \\\"NULLABLE\\\"\n  },\n  {\n    \\\"name\\\": \\\"date\\\",\n    \\\"type\\\": \\\"DATE\\\",\n    \\\"mode\\\": \\\"NULLABLE\\\"\n  }\n]\n"
}
resource "gcp_bigqueryanalyticshub_listing" "subscription" {
  location         = "us"
  data_exchange_id = gcp_bigqueryanalyticshub_dataexchange.subscription.data_exchange_id
  listing_id       = "my_test_listing"
  display_name     = "my_test_listing"
  description      = "Test Listing"
  restricted_export_config = {
    enabled = true
  }
  bigquery_dataset = {
    dataset = gcp_bigquery_dataset.subscription.id
    selected_resources = [{
      "table" = gcp_bigquery_table.subscription.id
    }]
  }
}
resource "gcp_bigqueryanalyticshub_dataexchangesubscription" "subscription" {
  project                = gcp_bigquery_dataset.subscription.project
  location               = "us"
  data_exchange_project  = gcp_bigqueryanalyticshub_dataexchange.subscription.project
  data_exchange_location = gcp_bigqueryanalyticshub_dataexchange.subscription.location
  data_exchange_id       = gcp_bigqueryanalyticshub_dataexchange.subscription.data_exchange_id
  subscription_id        = "my_subscription_id"
  subscriber_contact     = "[e-mail]"
  destination_dataset = {
    location = "us"
    dataset_reference = {
      project_id = gcp_bigquery_dataset.subscription.project
      dataset_id = "subscribed_dest_dataset"
    }
    friendly_name = "Subscribed Destination Dataset"
    description   = "Destination dataset for subscription"
    labels = {
      "environment" = "development"
      "owner"       = "team-a"
    }
  }
  #Subscriber's project
  refresh_policy = "ON_READ"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.bigqueryanalyticshub.DataExchange;
import com.pulumi.gcp.bigqueryanalyticshub.DataExchangeArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.DataExchangeSharingEnvironmentConfigArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.DataExchangeSharingEnvironmentConfigDcrExchangeConfigArgs;
import com.pulumi.gcp.bigquery.Dataset;
import com.pulumi.gcp.bigquery.DatasetArgs;
import com.pulumi.gcp.bigquery.Table;
import com.pulumi.gcp.bigquery.TableArgs;
import com.pulumi.gcp.bigqueryanalyticshub.Listing;
import com.pulumi.gcp.bigqueryanalyticshub.ListingArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.ListingRestrictedExportConfigArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.ListingBigqueryDatasetArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.ListingBigqueryDatasetSelectedResourceArgs;
import com.pulumi.gcp.bigqueryanalyticshub.DataExchangeSubscription;
import com.pulumi.gcp.bigqueryanalyticshub.DataExchangeSubscriptionArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.DataExchangeSubscriptionDestinationDatasetArgs;
import com.pulumi.gcp.bigqueryanalyticshub.inputs.DataExchangeSubscriptionDestinationDatasetDatasetReferenceArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 subscription = new DataExchange("subscription", DataExchangeArgs.builder()
            .location("us")
            .dataExchangeId("my_test_dataexchange")
            .displayName("my_test_dataexchange")
            .description("Test Data Exchange")
            .sharingEnvironmentConfig(DataExchangeSharingEnvironmentConfigArgs.builder()
                .dcrExchangeConfig(DataExchangeSharingEnvironmentConfigDcrExchangeConfigArgs.builder()
                    .build())
                .build())
            .build());

        var subscriptionDataset = new Dataset("subscriptionDataset", DatasetArgs.builder()
            .datasetId("listing_src_dataset")
            .friendlyName("listing_src_dataset")
            .description("Dataset for Listing")
            .location("us")
            .build());

        var subscriptionTable = new Table("subscriptionTable", TableArgs.builder()
            .deletionProtection(false)
            .tableId("listing_src_table")
            .datasetId(subscriptionDataset.datasetId())
            .schema("""
[
  {
    \"name\": \"name\",
    \"type\": \"STRING\",
    \"mode\": \"NULLABLE\"
  },
  {
    \"name\": \"post_abbr\",
    \"type\": \"STRING\",
    \"mode\": \"NULLABLE\"
  },
  {
    \"name\": \"date\",
    \"type\": \"DATE\",
    \"mode\": \"NULLABLE\"
  }
]
            """)
            .build());

        var subscriptionListing = new Listing("subscriptionListing", ListingArgs.builder()
            .location("us")
            .dataExchangeId(subscription.dataExchangeId())
            .listingId("my_test_listing")
            .displayName("my_test_listing")
            .description("Test Listing")
            .restrictedExportConfig(ListingRestrictedExportConfigArgs.builder()
                .enabled(true)
                .build())
            .bigqueryDataset(ListingBigqueryDatasetArgs.builder()
                .dataset(subscriptionDataset.id())
                .selectedResources(ListingBigqueryDatasetSelectedResourceArgs.builder()
                    .table(subscriptionTable.id())
                    .build())
                .build())
            .build());

        var subscriptionDataExchangeSubscription = new DataExchangeSubscription("subscriptionDataExchangeSubscription", DataExchangeSubscriptionArgs.builder()
            .project(subscriptionDataset.project())
            .location("us")
            .dataExchangeProject(subscription.project())
            .dataExchangeLocation(subscription.location())
            .dataExchangeId(subscription.dataExchangeId())
            .subscriptionId("my_subscription_id")
            .subscriberContact("[e-mail]")
            .destinationDataset(DataExchangeSubscriptionDestinationDatasetArgs.builder()
                .location("us")
                .datasetReference(DataExchangeSubscriptionDestinationDatasetDatasetReferenceArgs.builder()
                    .projectId(subscriptionDataset.project())
                    .datasetId("subscribed_dest_dataset")
                    .build())
                .friendlyName("Subscribed Destination Dataset")
                .description("Destination dataset for subscription")
                .labels(Map.ofEntries(
                    Map.entry("environment", "development"),
                    Map.entry("owner", "team-a")
                ))
                .build())
            .refreshPolicy("ON_READ")
            .build());

    }
}

resources:
  subscription:
    type: gcp:bigqueryanalyticshub:DataExchange
    properties:
      location: us
      dataExchangeId: my_test_dataexchange
      displayName: my_test_dataexchange
      description: Test Data Exchange
      sharingEnvironmentConfig:
        dcrExchangeConfig: {}
  subscriptionDataset:
    type: gcp:bigquery:Dataset
    name: subscription
    properties:
      datasetId: listing_src_dataset
      friendlyName: listing_src_dataset
      description: Dataset for Listing
      location: us
  subscriptionTable:
    type: gcp:bigquery:Table
    name: subscription
    properties:
      deletionProtection: false
      tableId: listing_src_table
      datasetId: ${subscriptionDataset.datasetId}
      schema: |
        [
          {
            \"name\": \"name\",
            \"type\": \"STRING\",
            \"mode\": \"NULLABLE\"
          },
          {
            \"name\": \"post_abbr\",
            \"type\": \"STRING\",
            \"mode\": \"NULLABLE\"
          },
          {
            \"name\": \"date\",
            \"type\": \"DATE\",
            \"mode\": \"NULLABLE\"
          }
        ]
  subscriptionListing:
    type: gcp:bigqueryanalyticshub:Listing
    name: subscription
    properties:
      location: us
      dataExchangeId: ${subscription.dataExchangeId}
      listingId: my_test_listing
      displayName: my_test_listing
      description: Test Listing
      restrictedExportConfig:
        enabled: true
      bigqueryDataset:
        dataset: ${subscriptionDataset.id}
        selectedResources:
          - table: ${subscriptionTable.id}
  subscriptionDataExchangeSubscription:
    type: gcp:bigqueryanalyticshub:DataExchangeSubscription
    name: subscription
    properties:
      project: ${subscriptionDataset.project}
      location: us
      dataExchangeProject: ${subscription.project}
      dataExchangeLocation: ${subscription.location}
      dataExchangeId: ${subscription.dataExchangeId}
      subscriptionId: my_subscription_id
      subscriberContact: [e-mail]
      destinationDataset:
        location: us
        datasetReference:
          projectId: ${subscriptionDataset.project}
          datasetId: subscribed_dest_dataset
        friendlyName: Subscribed Destination Dataset
        description: Destination dataset for subscription
        labels:
          environment: development
          owner: team-a
      refreshPolicy: ON_READ

Import

DataExchangeSubscription can be imported using any of these accepted formats:

• projects/{{project}}/locations/{{location}}/subscriptions/{{subscription_id}}
• {{project}}/{{location}}/{{subscription_id}}
• {{location}}/{{subscription_id}}

When using the pulumi import command, DataExchangeSubscription can be imported using one of the formats above. For example:

$ pulumi import gcp:bigqueryanalyticshub/dataExchangeSubscription:DataExchangeSubscription default projects/{{project}}/locations/{{location}}/subscriptions/{{subscription_id}}
$ pulumi import gcp:bigqueryanalyticshub/dataExchangeSubscription:DataExchangeSubscription default {{project}}/{{location}}/{{subscription_id}}
$ pulumi import gcp:bigqueryanalyticshub/dataExchangeSubscription:DataExchangeSubscription default {{location}}/{{subscription_id}}

Constructors

DataExchangeSubscription(String name, {DataExchangeSubscriptionArgs? args, CustomResourceOptions? options})

Creates a new DataExchangeSubscription. name The Pulumi resource name. args Arguments used to configure this DataExchangeSubscription. The set of arguments for DataExchangeSubscription. options Resource options controlling this resource's behavior.

DataExchangeSubscription.reference(String urn)

Creates a typed reference to an existing DataExchangeSubscription resource.

Properties

childResources → Set<Resource>

final, inherited

completionSources ↔ Map<String, IOutputCompletionSource>

late, final, inherited

creationTime ↔ Output<String>

Timestamp when the subscription was created.

late, final

dataExchange ↔ Output<String>

Output only. Resource name of the source Data Exchange. e.g. projects/123/locations/us/dataExchanges/456

late, final

dataExchangeId ↔ Output<String>

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.

late, final

dataExchangeLocation ↔ Output<String>

The name of the location of the Data Exchange.

late, final

dataExchangeProject ↔ Output<String>

The ID of the Google Cloud project where the Data Exchange is located.

late, final

deletionPolicy ↔ Output<String>

Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.

late, final

destinationDataset ↔ Output<DataExchangeSubscriptionDestinationDataset?>

BigQuery destination dataset to create for the subscriber. Structure is documented below.

late, final

hashCode → int

The hash code for this object.

no setter, inherited

id ↔ Output<String>

getter/setter pair, inherited

isCustom → bool

Returns whether this resource is provider-managed.

no setter, inherited

isProtected → bool

Returns whether this resource is protected from deletion.

no setter, inherited

isRemote → bool

Whether this resource is registered as remote.

no setter, inherited

isResourceReference → bool

Whether this instance represents a resource value returned over RPC.

final, inherited

lastModifyTime ↔ Output<String>

Timestamp when the subscription was last modified.

late, final

linkedDatasetMaps ↔ Output<List<DataExchangeSubscriptionLinkedDatasetMap>>

Output only. Map of listing resource names to associated linked resource, e.g. projects/123/locations/us/dataExchanges/456/listings/789 > projects/123/datasets/my_dataset For Data Exchange subscriptions, this map may contain multiple entries if the Data Exchange has multiple listings. Structure is documented below.

late, final

linkedResources ↔ Output<List<DataExchangeSubscriptionLinkedResource>>

Output only. Linked resources created in the subscription. Only contains values if state = STATE_ACTIVE. Structure is documented below.

late, final

location ↔ Output<String>

The geographic location where the Subscription (and its linked dataset) should reside. This is the subscriber's desired location for the created resources. See https://cloud.google.com/bigquery/docs/locations for supported locations.

late, final

logLinkedDatasetQueryUserEmail ↔ Output<bool>

Output only. By default, false. If true, the Subscriber agreed to the email sharing mandate that is enabled for DataExchange/Listing.

late, final

name ↔ Output<String>

The resource name of the subscription. e.g. "projects/myproject/locations/us/subscriptions/123"

late, final

organizationDisplayName ↔ Output<String>

Display name of the project of this subscription.

late, final

organizationId ↔ Output<String>

Organization of the project this subscription belongs to.

late, final

project ↔ Output<String>

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

late, final

refreshPolicy ↔ Output<String?>

Controls when the subscription is automatically refreshed by the provider.

late, final

resourceTransforms → List<ResourceTransform>

Inherited/explicit async transforms.

no setter, inherited

resourceType ↔ Output<String>

Listing shared asset type.

late, final

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

state ↔ Output<String>

Current state of the subscription.

late, final

subscriberContact ↔ Output<String?>

Email of the subscriber.

late, final

subscriptionId ↔ Output<String>

Name of the subscription to create.

late, final

transformations → List<ResourceTransformation>

Inherited/explicit legacy transformations.

no setter, inherited

urn ↔ Output<String>

late, final, inherited

Methods

failId(Object error) → void

Completes this resource ID with an error when registration fails.

inherited

failOutputs(Object error) → void

Completes all output properties with error.

inherited

failUrn(Object error) → void

Completes this resource URN with an error when registration fails.

inherited

getProvider(String moduleMember) → ProviderResource?

Returns provider for moduleMember's package, if configured.

inherited

getResourceName() → String

Returns this resource's logical name.

inherited

getResourceType() → String

Returns this resource's Pulumi type token.

inherited

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>

Registers a dynamic output property for this resource.

inherited

resolveId(String? value, {required bool isKnown}) → void

Resolves the provider-assigned ID for this resource.

inherited

resolveOutputs(Struct outputs) → void

Resolves all output properties from a monitor response payload.

inherited

resolveUrn(String value) → void

Resolves this resource's URN once assigned by the engine.

inherited

serializeProperties(Map<String, dynamic> properties) → Future<Struct>

Serializes resource properties for RPC transmission.

inherited

toString() → String

A string representation of this object.

inherited

Operators

operator ==(Object other) → bool

The equality operator.

inherited

Static Methods

get(String name, Input<String> id, {DataExchangeSubscriptionState? state, CustomResourceOptions? options}) → DataExchangeSubscription

Gets an existing DataExchangeSubscription resource's state with the given name and id.