Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Google Cloud (GCP) Classic
  4. API Docs
  5. dataplex
  6. MetadataFeed
Viewing docs for Google Cloud v9.30.0
published on Monday, Jul 13, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

gcp.dataplex.MetadataFeed

gcp logo
Viewing docs for Google Cloud v9.30.0
published on Monday, Jul 13, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

    A Dataplex Metadata Feed monitors Dataplex metadata entries in a specified scope and publishes notifications of changes to a Cloud Pub/Sub topic.

    Example Usage

    Dataplex Metadata Feed Basic

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

const project = gcp.organizations.getProject({});
const primary = new gcp.pubsub.Topic("primary", {name: "tf-test-feed-topic"});
const primaryPublisher = new gcp.pubsub.TopicIAMMember("primary_publisher", {
    topic: primary.name,
    role: "roles/pubsub.publisher",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-dataplex.iam.gserviceaccount.com`),
});
const primaryViewer = new gcp.pubsub.TopicIAMMember("primary_viewer", {
    topic: primary.name,
    role: "roles/pubsub.viewer",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-dataplex.iam.gserviceaccount.com`),
}, {
    dependsOn: [primaryPublisher],
});
const group = new gcp.dataplex.EntryGroup("group", {
    entryGroupId: "tf-test-feed-group",
    project: "my-project-name",
    location: "us-central1",
});
const type = new gcp.dataplex.EntryType("type", {
    entryTypeId: "tf-test-feed-type",
    project: "my-project-name",
    location: "us-central1",
});
const aspect = new gcp.dataplex.AspectType("aspect", {
    aspectTypeId: "tf-test-feed-aspect",
    project: "my-project-name",
    location: "us-central1",
    metadataTemplate: `{
  \\"name\\": \\"tf-test-template\\",
  \\"type\\": \\"record\\",
  \\"recordFields\\": [
    {
      \\"name\\": \\"type\\",
      \\"type\\": \\"enum\\",
      \\"annotations\\": {
        \\"displayName\\": \\"Type\\",
        \\"description\\": \\"Specifies the type of view represented by the entry.\\"
      },
      \\"index\\": 1,
      \\"constraints\\": {
        \\"required\\": true
      },
      \\"enumValues\\": [
        {
          \\"name\\": \\"VIEW\\",
          \\"index\\": 1
        }
      ]
    }
  ]
}
`,
});
const primaryMetadataFeed = new gcp.dataplex.MetadataFeed("primary", {
    metadataFeedId: "tf-test-feed",
    location: "us-central1",
    project: "my-project-name",
    pubsubTopic: primary.id,
    labels: {
        foo: "bar",
    },
    filters: {
        aspectTypes: [pulumi.all([project, aspect.aspectTypeId]).apply(([project, aspectTypeId]) => `projects/${project.number}/locations/us-central1/aspectTypes/${aspectTypeId}`)],
        changeTypes: ["CREATE"],
        entryTypes: [pulumi.all([project, type.entryTypeId]).apply(([project, entryTypeId]) => `projects/${project.number}/locations/us-central1/entryTypes/${entryTypeId}`)],
    },
    scope: {
        entryGroups: [pulumi.all([project, group.entryGroupId]).apply(([project, entryGroupId]) => `projects/${project.number}/locations/us-central1/entryGroups/${entryGroupId}`)],
    },
}, {
    dependsOn: [
        primaryPublisher,
        primaryViewer,
    ],
});

    import pulumi
import pulumi_gcp as gcp

project = gcp.organizations.get_project()
primary = gcp.pubsub.Topic("primary", name="tf-test-feed-topic")
primary_publisher = gcp.pubsub.TopicIAMMember("primary_publisher",
    topic=primary.name,
    role="roles/pubsub.publisher",
    member=f"serviceAccount:service-{project.number}@gcp-sa-dataplex.iam.gserviceaccount.com")
primary_viewer = gcp.pubsub.TopicIAMMember("primary_viewer",
    topic=primary.name,
    role="roles/pubsub.viewer",
    member=f"serviceAccount:service-{project.number}@gcp-sa-dataplex.iam.gserviceaccount.com",
    opts = pulumi.ResourceOptions(depends_on=[primary_publisher]))
group = gcp.dataplex.EntryGroup("group",
    entry_group_id="tf-test-feed-group",
    project="my-project-name",
    location="us-central1")
type = gcp.dataplex.EntryType("type",
    entry_type_id="tf-test-feed-type",
    project="my-project-name",
    location="us-central1")
aspect = gcp.dataplex.AspectType("aspect",
    aspect_type_id="tf-test-feed-aspect",
    project="my-project-name",
    location="us-central1",
    metadata_template="""{
  \"name\": \"tf-test-template\",
  \"type\": \"record\",
  \"recordFields\": [
    {
      \"name\": \"type\",
      \"type\": \"enum\",
      \"annotations\": {
        \"displayName\": \"Type\",
        \"description\": \"Specifies the type of view represented by the entry.\"
      },
      \"index\": 1,
      \"constraints\": {
        \"required\": true
      },
      \"enumValues\": [
        {
          \"name\": \"VIEW\",
          \"index\": 1
        }
      ]
    }
  ]
}
""")
primary_metadata_feed = gcp.dataplex.MetadataFeed("primary",
    metadata_feed_id="tf-test-feed",
    location="us-central1",
    project="my-project-name",
    pubsub_topic=primary.id,
    labels={
        "foo": "bar",
    },
    filters={
        "aspect_types": [aspect.aspect_type_id.apply(lambda aspect_type_id: f"projects/{project.number}/locations/us-central1/aspectTypes/{aspect_type_id}")],
        "change_types": ["CREATE"],
        "entry_types": [type.entry_type_id.apply(lambda entry_type_id: f"projects/{project.number}/locations/us-central1/entryTypes/{entry_type_id}")],
    },
    scope={
        "entry_groups": [group.entry_group_id.apply(lambda entry_group_id: f"projects/{project.number}/locations/us-central1/entryGroups/{entry_group_id}")],
    },
    opts = pulumi.ResourceOptions(depends_on=[
            primary_publisher,
            primary_viewer,
        ]))

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataplex"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/pubsub"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
		if err != nil {
			return err
		}
		primary, err := pubsub.NewTopic(ctx, "primary", &pubsub.TopicArgs{
			Name: pulumi.String("tf-test-feed-topic"),
		})
		if err != nil {
			return err
		}
		primaryPublisher, err := pubsub.NewTopicIAMMember(ctx, "primary_publisher", &pubsub.TopicIAMMemberArgs{
			Topic:  primary.Name,
			Role:   pulumi.String("roles/pubsub.publisher"),
			Member: pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-dataplex.iam.gserviceaccount.com", project.Number),
		})
		if err != nil {
			return err
		}
		primaryViewer, err := pubsub.NewTopicIAMMember(ctx, "primary_viewer", &pubsub.TopicIAMMemberArgs{
			Topic:  primary.Name,
			Role:   pulumi.String("roles/pubsub.viewer"),
			Member: pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-dataplex.iam.gserviceaccount.com", project.Number),
		}, pulumi.DependsOn([]pulumi.Resource{
			primaryPublisher,
		}))
		if err != nil {
			return err
		}
		group, err := dataplex.NewEntryGroup(ctx, "group", &dataplex.EntryGroupArgs{
			EntryGroupId: pulumi.String("tf-test-feed-group"),
			Project:      pulumi.String("my-project-name"),
			Location:     pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_type, err := dataplex.NewEntryType(ctx, "type", &dataplex.EntryTypeArgs{
			EntryTypeId: pulumi.String("tf-test-feed-type"),
			Project:     pulumi.String("my-project-name"),
			Location:    pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		aspect, err := dataplex.NewAspectType(ctx, "aspect", &dataplex.AspectTypeArgs{
			AspectTypeId: pulumi.String("tf-test-feed-aspect"),
			Project:      pulumi.String("my-project-name"),
			Location:     pulumi.String("us-central1"),
			MetadataTemplate: pulumi.String(`{
  \"name\": \"tf-test-template\",
  \"type\": \"record\",
  \"recordFields\": [
    {
      \"name\": \"type\",
      \"type\": \"enum\",
      \"annotations\": {
        \"displayName\": \"Type\",
        \"description\": \"Specifies the type of view represented by the entry.\"
      },
      \"index\": 1,
      \"constraints\": {
        \"required\": true
      },
      \"enumValues\": [
        {
          \"name\": \"VIEW\",
          \"index\": 1
        }
      ]
    }
  ]
}
`),
		})
		if err != nil {
			return err
		}
		_, err = dataplex.NewMetadataFeed(ctx, "primary", &dataplex.MetadataFeedArgs{
			MetadataFeedId: pulumi.String("tf-test-feed"),
			Location:       pulumi.String("us-central1"),
			Project:        pulumi.String("my-project-name"),
			PubsubTopic:    primary.ID(),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Filters: &dataplex.MetadataFeedFiltersArgs{
				AspectTypes: pulumi.StringArray{
					aspect.AspectTypeId.ApplyT(func(aspectTypeId *string) (string, error) {
						return fmt.Sprintf("projects/%v/locations/us-central1/aspectTypes/%v", project.Number, aspectTypeId), nil
					}).(pulumi.StringOutput),
				},
				ChangeTypes: pulumi.StringArray{
					pulumi.String("CREATE"),
				},
				EntryTypes: pulumi.StringArray{
					_type.EntryTypeId.ApplyT(func(entryTypeId *string) (string, error) {
						return fmt.Sprintf("projects/%v/locations/us-central1/entryTypes/%v", project.Number, entryTypeId), nil
					}).(pulumi.StringOutput),
				},
			},
			Scope: &dataplex.MetadataFeedScopeArgs{
				EntryGroups: pulumi.StringArray{
					group.EntryGroupId.ApplyT(func(entryGroupId *string) (string, error) {
						return fmt.Sprintf("projects/%v/locations/us-central1/entryGroups/%v", project.Number, entryGroupId), nil
					}).(pulumi.StringOutput),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			primaryPublisher,
			primaryViewer,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var project = Gcp.Organizations.GetProject.Invoke();

    var primary = new Gcp.PubSub.Topic("primary", new()
    {
        Name = "tf-test-feed-topic",
    });

    var primaryPublisher = new Gcp.PubSub.TopicIAMMember("primary_publisher", new()
    {
        Topic = primary.Name,
        Role = "roles/pubsub.publisher",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-dataplex.iam.gserviceaccount.com",
    });

    var primaryViewer = new Gcp.PubSub.TopicIAMMember("primary_viewer", new()
    {
        Topic = primary.Name,
        Role = "roles/pubsub.viewer",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-dataplex.iam.gserviceaccount.com",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            primaryPublisher,
        },
    });

    var @group = new Gcp.DataPlex.EntryGroup("group", new()
    {
        EntryGroupId = "tf-test-feed-group",
        Project = "my-project-name",
        Location = "us-central1",
    });

    var type = new Gcp.DataPlex.EntryType("type", new()
    {
        EntryTypeId = "tf-test-feed-type",
        Project = "my-project-name",
        Location = "us-central1",
    });

    var aspect = new Gcp.DataPlex.AspectType("aspect", new()
    {
        AspectTypeId = "tf-test-feed-aspect",
        Project = "my-project-name",
        Location = "us-central1",
        MetadataTemplate = @"{
  \""name\"": \""tf-test-template\"",
  \""type\"": \""record\"",
  \""recordFields\"": [
    {
      \""name\"": \""type\"",
      \""type\"": \""enum\"",
      \""annotations\"": {
        \""displayName\"": \""Type\"",
        \""description\"": \""Specifies the type of view represented by the entry.\""
      },
      \""index\"": 1,
      \""constraints\"": {
        \""required\"": true
      },
      \""enumValues\"": [
        {
          \""name\"": \""VIEW\"",
          \""index\"": 1
        }
      ]
    }
  ]
}
",
    });

    var primaryMetadataFeed = new Gcp.DataPlex.MetadataFeed("primary", new()
    {
        MetadataFeedId = "tf-test-feed",
        Location = "us-central1",
        Project = "my-project-name",
        PubsubTopic = primary.Id,
        Labels = 
        {
            { "foo", "bar" },
        },
        Filters = new Gcp.DataPlex.Inputs.MetadataFeedFiltersArgs
        {
            AspectTypes = new[]
            {
                Output.Tuple(project, aspect.AspectTypeId).Apply(values =>
                {
                    var project = values.Item1;
                    var aspectTypeId = values.Item2;
                    return $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}/locations/us-central1/aspectTypes/{aspectTypeId}";
                }),
            },
            ChangeTypes = new[]
            {
                "CREATE",
            },
            EntryTypes = new[]
            {
                Output.Tuple(project, type.EntryTypeId).Apply(values =>
                {
                    var project = values.Item1;
                    var entryTypeId = values.Item2;
                    return $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}/locations/us-central1/entryTypes/{entryTypeId}";
                }),
            },
        },
        Scope = new Gcp.DataPlex.Inputs.MetadataFeedScopeArgs
        {
            EntryGroups = new[]
            {
                Output.Tuple(project, @group.EntryGroupId).Apply(values =>
                {
                    var project = values.Item1;
                    var entryGroupId = values.Item2;
                    return $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}/locations/us-central1/entryGroups/{entryGroupId}";
                }),
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            primaryPublisher,
            primaryViewer,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.pubsub.Topic;
import com.pulumi.gcp.pubsub.TopicArgs;
import com.pulumi.gcp.pubsub.TopicIAMMember;
import com.pulumi.gcp.pubsub.TopicIAMMemberArgs;
import com.pulumi.gcp.dataplex.EntryGroup;
import com.pulumi.gcp.dataplex.EntryGroupArgs;
import com.pulumi.gcp.dataplex.EntryType;
import com.pulumi.gcp.dataplex.EntryTypeArgs;
import com.pulumi.gcp.dataplex.AspectType;
import com.pulumi.gcp.dataplex.AspectTypeArgs;
import com.pulumi.gcp.dataplex.MetadataFeed;
import com.pulumi.gcp.dataplex.MetadataFeedArgs;
import com.pulumi.gcp.dataplex.inputs.MetadataFeedFiltersArgs;
import com.pulumi.gcp.dataplex.inputs.MetadataFeedScopeArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
            .build());

        var primary = new Topic("primary", TopicArgs.builder()
            .name("tf-test-feed-topic")
            .build());

        var primaryPublisher = new TopicIAMMember("primaryPublisher", TopicIAMMemberArgs.builder()
            .topic(primary.name())
            .role("roles/pubsub.publisher")
            .member(String.format("serviceAccount:service-%s@gcp-sa-dataplex.iam.gserviceaccount.com", project.number()))
            .build());

        var primaryViewer = new TopicIAMMember("primaryViewer", TopicIAMMemberArgs.builder()
            .topic(primary.name())
            .role("roles/pubsub.viewer")
            .member(String.format("serviceAccount:service-%s@gcp-sa-dataplex.iam.gserviceaccount.com", project.number()))
            .build(), CustomResourceOptions.builder()
                .dependsOn(primaryPublisher)
                .build());

        var group = new EntryGroup("group", EntryGroupArgs.builder()
            .entryGroupId("tf-test-feed-group")
            .project("my-project-name")
            .location("us-central1")
            .build());

        var type = new EntryType("type", EntryTypeArgs.builder()
            .entryTypeId("tf-test-feed-type")
            .project("my-project-name")
            .location("us-central1")
            .build());

        var aspect = new AspectType("aspect", AspectTypeArgs.builder()
            .aspectTypeId("tf-test-feed-aspect")
            .project("my-project-name")
            .location("us-central1")
            .metadataTemplate("""
{
  \"name\": \"tf-test-template\",
  \"type\": \"record\",
  \"recordFields\": [
    {
      \"name\": \"type\",
      \"type\": \"enum\",
      \"annotations\": {
        \"displayName\": \"Type\",
        \"description\": \"Specifies the type of view represented by the entry.\"
      },
      \"index\": 1,
      \"constraints\": {
        \"required\": true
      },
      \"enumValues\": [
        {
          \"name\": \"VIEW\",
          \"index\": 1
        }
      ]
    }
  ]
}
            """)
            .build());

        var primaryMetadataFeed = new MetadataFeed("primaryMetadataFeed", MetadataFeedArgs.builder()
            .metadataFeedId("tf-test-feed")
            .location("us-central1")
            .project("my-project-name")
            .pubsubTopic(primary.id())
            .labels(Map.of("foo", "bar"))
            .filters(MetadataFeedFiltersArgs.builder()
                .aspectTypes(aspect.aspectTypeId().applyValue(_aspectTypeId -> String.format("projects/%s/locations/us-central1/aspectTypes/%s", project.number(),_aspectTypeId)))
                .changeTypes("CREATE")
                .entryTypes(type.entryTypeId().applyValue(_entryTypeId -> String.format("projects/%s/locations/us-central1/entryTypes/%s", project.number(),_entryTypeId)))
                .build())
            .scope(MetadataFeedScopeArgs.builder()
                .entryGroups(group.entryGroupId().applyValue(_entryGroupId -> String.format("projects/%s/locations/us-central1/entryGroups/%s", project.number(),_entryGroupId)))
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    primaryPublisher,
                    primaryViewer)
                .build());

    }
}

    resources:
  primary:
    type: gcp:pubsub:Topic
    properties:
      name: tf-test-feed-topic
  primaryPublisher:
    type: gcp:pubsub:TopicIAMMember
    name: primary_publisher
    properties:
      topic: ${primary.name}
      role: roles/pubsub.publisher
      member: serviceAccount:service-${project.number}@gcp-sa-dataplex.iam.gserviceaccount.com
  primaryViewer:
    type: gcp:pubsub:TopicIAMMember
    name: primary_viewer
    properties:
      topic: ${primary.name}
      role: roles/pubsub.viewer
      member: serviceAccount:service-${project.number}@gcp-sa-dataplex.iam.gserviceaccount.com
    options:
      dependsOn:
        - ${primaryPublisher}
  group:
    type: gcp:dataplex:EntryGroup
    properties:
      entryGroupId: tf-test-feed-group
      project: my-project-name
      location: us-central1
  type:
    type: gcp:dataplex:EntryType
    properties:
      entryTypeId: tf-test-feed-type
      project: my-project-name
      location: us-central1
  aspect:
    type: gcp:dataplex:AspectType
    properties:
      aspectTypeId: tf-test-feed-aspect
      project: my-project-name
      location: us-central1
      metadataTemplate: |
        {
          \"name\": \"tf-test-template\",
          \"type\": \"record\",
          \"recordFields\": [
            {
              \"name\": \"type\",
              \"type\": \"enum\",
              \"annotations\": {
                \"displayName\": \"Type\",
                \"description\": \"Specifies the type of view represented by the entry.\"
              },
              \"index\": 1,
              \"constraints\": {
                \"required\": true
              },
              \"enumValues\": [
                {
                  \"name\": \"VIEW\",
                  \"index\": 1
                }
              ]
            }
          ]
        }
  primaryMetadataFeed:
    type: gcp:dataplex:MetadataFeed
    name: primary
    properties:
      metadataFeedId: tf-test-feed
      location: us-central1
      project: my-project-name
      pubsubTopic: ${primary.id}
      labels:
        foo: bar
      filters:
        aspectTypes:
          - projects/${project.number}/locations/us-central1/aspectTypes/${aspect.aspectTypeId}
        changeTypes:
          - CREATE
        entryTypes:
          - projects/${project.number}/locations/us-central1/entryTypes/${type.entryTypeId}
      scope:
        entryGroups:
          - projects/${project.number}/locations/us-central1/entryGroups/${group.entryGroupId}
    options:
      dependsOn:
        - ${primaryPublisher}
        - ${primaryViewer}
variables:
  project:
    fn::invoke:
      function: gcp:organizations:getProject
      arguments: {}

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

data "gcp_organizations_getproject" "project" {
}

resource "gcp_pubsub_topic" "primary" {
  name = "tf-test-feed-topic"
}
resource "gcp_pubsub_topiciammember" "primary_publisher" {
  topic  = gcp_pubsub_topic.primary.name
  role   = "roles/pubsub.publisher"
  member ="serviceAccount:service-${data.gcp_organizations_getproject.project.number}@gcp-sa-dataplex.iam.gserviceaccount.com"
}
resource "gcp_pubsub_topiciammember" "primary_viewer" {
  depends_on = [gcp_pubsub_topiciammember.primary_publisher]
  topic      = gcp_pubsub_topic.primary.name
  role       = "roles/pubsub.viewer"
  member     ="serviceAccount:service-${data.gcp_organizations_getproject.project.number}@gcp-sa-dataplex.iam.gserviceaccount.com"
}
resource "gcp_dataplex_entrygroup" "group" {
  entry_group_id = "tf-test-feed-group"
  project        = "my-project-name"
  location       = "us-central1"
}
resource "gcp_dataplex_entrytype" "type" {
  entry_type_id = "tf-test-feed-type"
  project       = "my-project-name"
  location      = "us-central1"
}
resource "gcp_dataplex_aspecttype" "aspect" {
  aspect_type_id    = "tf-test-feed-aspect"
  project           = "my-project-name"
  location          = "us-central1"
  metadata_template = "{\n  \\\"name\\\": \\\"tf-test-template\\\",\n  \\\"type\\\": \\\"record\\\",\n  \\\"recordFields\\\": [\n    {\n      \\\"name\\\": \\\"type\\\",\n      \\\"type\\\": \\\"enum\\\",\n      \\\"annotations\\\": {\n        \\\"displayName\\\": \\\"Type\\\",\n        \\\"description\\\": \\\"Specifies the type of view represented by the entry.\\\"\n      },\n      \\\"index\\\": 1,\n      \\\"constraints\\\": {\n        \\\"required\\\": true\n      },\n      \\\"enumValues\\\": [\n        {\n          \\\"name\\\": \\\"VIEW\\\",\n          \\\"index\\\": 1\n        }\n      ]\n    }\n  ]\n}\n"
}
resource "gcp_dataplex_metadatafeed" "primary" {
  depends_on       = [gcp_pubsub_topiciammember.primary_publisher, gcp_pubsub_topiciammember.primary_viewer]
  metadata_feed_id = "tf-test-feed"
  location         = "us-central1"
  project          = "my-project-name"
  pubsub_topic     = gcp_pubsub_topic.primary.id
  labels = {
    "foo" = "bar"
  }
  filters = {
    aspect_types = ["projects/${data.gcp_organizations_getproject.project.number}/locations/us-central1/aspectTypes/${gcp_dataplex_aspecttype.aspect.aspect_type_id}"]
    change_types = ["CREATE"]
    entry_types  = ["projects/${data.gcp_organizations_getproject.project.number}/locations/us-central1/entryTypes/${gcp_dataplex_entrytype.type.entry_type_id}"]
  }
  scope = {
    entry_groups = ["projects/${data.gcp_organizations_getproject.project.number}/locations/us-central1/entryGroups/${gcp_dataplex_entrygroup.group.entry_group_id}"]
  }
}

    Create MetadataFeed Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new MetadataFeed(name: string, args: MetadataFeedArgs, opts?: CustomResourceOptions);
    @overload
def MetadataFeed(resource_name: str,
                 args: MetadataFeedArgs,
                 opts: Optional[ResourceOptions] = None)

@overload
def MetadataFeed(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 location: Optional[str] = None,
                 metadata_feed_id: Optional[str] = None,
                 scope: Optional[MetadataFeedScopeArgs] = None,
                 deletion_policy: Optional[str] = None,
                 filters: Optional[MetadataFeedFiltersArgs] = None,
                 labels: Optional[Mapping[str, str]] = None,
                 project: Optional[str] = None,
                 pubsub_topic: Optional[str] = None)
    func NewMetadataFeed(ctx *Context, name string, args MetadataFeedArgs, opts ...ResourceOption) (*MetadataFeed, error)
    public MetadataFeed(string name, MetadataFeedArgs args, CustomResourceOptions? opts = null)
    public MetadataFeed(String name, MetadataFeedArgs args)
public MetadataFeed(String name, MetadataFeedArgs args, CustomResourceOptions options)

    type: gcp:dataplex:MetadataFeed
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "gcp_dataplex_metadatafeed" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args MetadataFeedArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args MetadataFeedArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args MetadataFeedArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args MetadataFeedArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args MetadataFeedArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var metadataFeedResource = new Gcp.DataPlex.MetadataFeed("metadataFeedResource", new()
{
    Location = "string",
    MetadataFeedId = "string",
    Scope = new Gcp.DataPlex.Inputs.MetadataFeedScopeArgs
    {
        EntryGroups = new[]
        {
            "string",
        },
        OrganizationLevel = false,
        Projects = new[]
        {
            "string",
        },
    },
    DeletionPolicy = "string",
    Filters = new Gcp.DataPlex.Inputs.MetadataFeedFiltersArgs
    {
        AspectTypes = new[]
        {
            "string",
        },
        ChangeTypes = new[]
        {
            "string",
        },
        EntryTypes = new[]
        {
            "string",
        },
    },
    Labels = 
    {
        { "string", "string" },
    },
    Project = "string",
    PubsubTopic = "string",
});

    example, err := dataplex.NewMetadataFeed(ctx, "metadataFeedResource", &dataplex.MetadataFeedArgs{
	Location:       pulumi.String("string"),
	MetadataFeedId: pulumi.String("string"),
	Scope: &dataplex.MetadataFeedScopeArgs{
		EntryGroups: pulumi.StringArray{
			pulumi.String("string"),
		},
		OrganizationLevel: pulumi.Bool(false),
		Projects: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	DeletionPolicy: pulumi.String("string"),
	Filters: &dataplex.MetadataFeedFiltersArgs{
		AspectTypes: pulumi.StringArray{
			pulumi.String("string"),
		},
		ChangeTypes: pulumi.StringArray{
			pulumi.String("string"),
		},
		EntryTypes: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Project:     pulumi.String("string"),
	PubsubTopic: pulumi.String("string"),
})

    resource "gcp_dataplex_metadatafeed" "metadataFeedResource" {
  location         = "string"
  metadata_feed_id = "string"
  scope = {
    entry_groups       = ["string"]
    organization_level = false
    projects           = ["string"]
  }
  deletion_policy = "string"
  filters = {
    aspect_types = ["string"]
    change_types = ["string"]
    entry_types  = ["string"]
  }
  labels = {
    "string" = "string"
  }
  project      = "string"
  pubsub_topic = "string"
}

    var metadataFeedResource = new MetadataFeed("metadataFeedResource", MetadataFeedArgs.builder()
    .location("string")
    .metadataFeedId("string")
    .scope(MetadataFeedScopeArgs.builder()
        .entryGroups("string")
        .organizationLevel(false)
        .projects("string")
        .build())
    .deletionPolicy("string")
    .filters(MetadataFeedFiltersArgs.builder()
        .aspectTypes("string")
        .changeTypes("string")
        .entryTypes("string")
        .build())
    .labels(Map.of("string", "string"))
    .project("string")
    .pubsubTopic("string")
    .build());

    metadata_feed_resource = gcp.dataplex.MetadataFeed("metadataFeedResource",
    location="string",
    metadata_feed_id="string",
    scope={
        "entry_groups": ["string"],
        "organization_level": False,
        "projects": ["string"],
    },
    deletion_policy="string",
    filters={
        "aspect_types": ["string"],
        "change_types": ["string"],
        "entry_types": ["string"],
    },
    labels={
        "string": "string",
    },
    project="string",
    pubsub_topic="string")

    const metadataFeedResource = new gcp.dataplex.MetadataFeed("metadataFeedResource", {
    location: "string",
    metadataFeedId: "string",
    scope: {
        entryGroups: ["string"],
        organizationLevel: false,
        projects: ["string"],
    },
    deletionPolicy: "string",
    filters: {
        aspectTypes: ["string"],
        changeTypes: ["string"],
        entryTypes: ["string"],
    },
    labels: {
        string: "string",
    },
    project: "string",
    pubsubTopic: "string",
});

    type: gcp:dataplex:MetadataFeed
properties:
    deletionPolicy: string
    filters:
        aspectTypes:
            - string
        changeTypes:
            - string
        entryTypes:
            - string
    labels:
        string: string
    location: string
    metadataFeedId: string
    project: string
    pubsubTopic: string
    scope:
        entryGroups:
            - string
        organizationLevel: false
        projects:
            - string

    MetadataFeed Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The MetadataFeed resource accepts the following input properties:

    Location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    MetadataFeedId string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    Scope MetadataFeedScope
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    DeletionPolicy 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.
    Filters MetadataFeedFilters
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    Labels Dictionary<string, string>
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PubsubTopic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    Location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    MetadataFeedId string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    Scope MetadataFeedScopeArgs
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    DeletionPolicy 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.
    Filters MetadataFeedFiltersArgs
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    Labels map[string]string
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PubsubTopic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadata_feed_id string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    scope object
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    deletion_policy 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.
    filters object
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels map(string)
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsub_topic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    location String
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadataFeedId String
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    scope MetadataFeedScope
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    deletionPolicy 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.
    filters MetadataFeedFilters
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels Map<String,String>
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsubTopic String
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadataFeedId string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    scope MetadataFeedScope
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    deletionPolicy 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.
    filters MetadataFeedFilters
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels {[key: string]: string}
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsubTopic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    location str
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadata_feed_id str
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    scope MetadataFeedScopeArgs
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    deletion_policy str
    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.
    filters MetadataFeedFiltersArgs
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels Mapping[str, str]
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsub_topic str
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    location String
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadataFeedId String
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    scope Property Map
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    deletionPolicy 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.
    filters Property Map
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels Map<String>
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsubTopic String
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the MetadataFeed resource produces the following output properties:

    CreateTime string
    The time when the feed was created.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    Uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    UpdateTime string
    The time when the feed was updated.
    CreateTime string
    The time when the feed was created.
    EffectiveLabels map[string]string
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    Uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    UpdateTime string
    The time when the feed was updated.
    create_time string
    The time when the feed was created.
    effective_labels map(string)
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    pulumi_labels map(string)
    The combination of labels configured directly on the resource and default labels configured on the provider.
    uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    update_time string
    The time when the feed was updated.
    createTime String
    The time when the feed was created.
    effectiveLabels Map<String,String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    uid String
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    updateTime String
    The time when the feed was updated.
    createTime string
    The time when the feed was created.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    updateTime string
    The time when the feed was updated.
    create_time str
    The time when the feed was created.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    uid str
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    update_time str
    The time when the feed was updated.
    createTime String
    The time when the feed was created.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    uid String
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    updateTime String
    The time when the feed was updated.

    Look up Existing MetadataFeed Resource

    Get an existing MetadataFeed resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: MetadataFeedState, opts?: CustomResourceOptions): MetadataFeed
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        create_time: Optional[str] = None,
        deletion_policy: Optional[str] = None,
        effective_labels: Optional[Mapping[str, str]] = None,
        filters: Optional[MetadataFeedFiltersArgs] = None,
        labels: Optional[Mapping[str, str]] = None,
        location: Optional[str] = None,
        metadata_feed_id: Optional[str] = None,
        name: Optional[str] = None,
        project: Optional[str] = None,
        pubsub_topic: Optional[str] = None,
        pulumi_labels: Optional[Mapping[str, str]] = None,
        scope: Optional[MetadataFeedScopeArgs] = None,
        uid: Optional[str] = None,
        update_time: Optional[str] = None) -> MetadataFeed
    func GetMetadataFeed(ctx *Context, name string, id IDInput, state *MetadataFeedState, opts ...ResourceOption) (*MetadataFeed, error)
    public static MetadataFeed Get(string name, Input<string> id, MetadataFeedState? state, CustomResourceOptions? opts = null)
    public static MetadataFeed get(String name, Output<String> id, MetadataFeedState state, CustomResourceOptions options)
    resources:  _:    type: gcp:dataplex:MetadataFeed    get:      id: ${id}
    import {
  to = gcp_dataplex_metadatafeed.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CreateTime string
    The time when the feed was created.
    DeletionPolicy 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.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Filters MetadataFeedFilters
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    Labels Dictionary<string, string>
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    MetadataFeedId string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    Name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PubsubTopic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    Scope MetadataFeedScope
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    Uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    UpdateTime string
    The time when the feed was updated.
    CreateTime string
    The time when the feed was created.
    DeletionPolicy 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.
    EffectiveLabels map[string]string
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Filters MetadataFeedFiltersArgs
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    Labels map[string]string
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    MetadataFeedId string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    Name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PubsubTopic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    Scope MetadataFeedScopeArgs
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    Uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    UpdateTime string
    The time when the feed was updated.
    create_time string
    The time when the feed was created.
    deletion_policy 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.
    effective_labels map(string)
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    filters object
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels map(string)
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadata_feed_id string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsub_topic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    pulumi_labels map(string)
    The combination of labels configured directly on the resource and default labels configured on the provider.
    scope object
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    update_time string
    The time when the feed was updated.
    createTime String
    The time when the feed was created.
    deletionPolicy 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.
    effectiveLabels Map<String,String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    filters MetadataFeedFilters
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels Map<String,String>
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location String
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadataFeedId String
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    name String
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsubTopic String
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    scope MetadataFeedScope
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    uid String
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    updateTime String
    The time when the feed was updated.
    createTime string
    The time when the feed was created.
    deletionPolicy 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.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    filters MetadataFeedFilters
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels {[key: string]: string}
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location string
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadataFeedId string
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    name string
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsubTopic string
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    scope MetadataFeedScope
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    uid string
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    updateTime string
    The time when the feed was updated.
    create_time str
    The time when the feed was created.
    deletion_policy str
    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.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    filters MetadataFeedFiltersArgs
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels Mapping[str, str]
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location str
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadata_feed_id str
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    name str
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsub_topic str
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    scope MetadataFeedScopeArgs
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    uid str
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    update_time str
    The time when the feed was updated.
    createTime String
    The time when the feed was created.
    deletionPolicy 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.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    filters Property Map
    Filters defines the type of changes that you want to listen to. You can have multiple entry type filters and multiple aspect type filters. All of the entry type filters are OR'ed together. All of the aspect type filters are OR'ed together. All of the entry type filters and aspect type filters are AND'ed together. Structure is documented below.
    labels Map<String>
    User-defined labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location String
    Resource ID segment making up resource name. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
    metadataFeedId String
    The metadata job ID. If not provided, a unique ID is generated with the prefix metadata-job-.
    name String
    Identifier. The resource name of the metadata feed, in the format projects/{project_id_or_number}/locations/{location_id}/metadataFeeds/{metadata_feed_id}.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pubsubTopic String
    The pubsub topic that you want the metadata feed messages to publish to. Please grant Dataplex service account the permission to publish messages to the topic. The service account is: service-{PROJECT_NUMBER}@gcp-sa-dataplex.iam.gserviceaccount.com.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    scope Property Map
    Scope defines the scope of the metadata feed. Scopes are exclusive. Only one of the scopes can be specified. Structure is documented below.
    uid String
    A system-generated, globally unique ID for the metadata job. If the metadata job is deleted and then re-created with the same name, this ID is different.
    updateTime String
    The time when the feed was updated.

    Supporting Types

    MetadataFeedFilters, MetadataFeedFiltersArgs

    AspectTypes List<string>
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    ChangeTypes List<string>
    The type of change that you want to listen to. If not specified, all changes are published.
    EntryTypes List<string>
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.
    AspectTypes []string
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    ChangeTypes []string
    The type of change that you want to listen to. If not specified, all changes are published.
    EntryTypes []string
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.
    aspect_types list(string)
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    change_types list(string)
    The type of change that you want to listen to. If not specified, all changes are published.
    entry_types list(string)
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.
    aspectTypes List<String>
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    changeTypes List<String>
    The type of change that you want to listen to. If not specified, all changes are published.
    entryTypes List<String>
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.
    aspectTypes string[]
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    changeTypes string[]
    The type of change that you want to listen to. If not specified, all changes are published.
    entryTypes string[]
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.
    aspect_types Sequence[str]
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    change_types Sequence[str]
    The type of change that you want to listen to. If not specified, all changes are published.
    entry_types Sequence[str]
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.
    aspectTypes List<String>
    The aspect types that you want to listen to. Depending on how the aspect is attached to the entry, in the format: projects/{project_id_or_number}/locations/{location}/aspectTypes/{aspect_type_id}.
    changeTypes List<String>
    The type of change that you want to listen to. If not specified, all changes are published.
    entryTypes List<String>
    The entry types that you want to listen to, specified as relative resource names in the format projects/{project_id_or_number}/locations/{location}/entryTypes/{entry_type_id}. Only entries that belong to the specified entry types are published.

    MetadataFeedScope, MetadataFeedScopeArgs

    EntryGroups List<string>
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    OrganizationLevel bool
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    Projects List<string>
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.
    EntryGroups []string
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    OrganizationLevel bool
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    Projects []string
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.
    entry_groups list(string)
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    organization_level bool
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    projects list(string)
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.
    entryGroups List<String>
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    organizationLevel Boolean
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    projects List<String>
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.
    entryGroups string[]
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    organizationLevel boolean
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    projects string[]
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.
    entry_groups Sequence[str]
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    organization_level bool
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    projects Sequence[str]
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.
    entryGroups List<String>
    The entry groups whose entries you want to listen to. Must be in the format: projects/{project_id_or_number}/locations/{location_id}/entryGroups/{entry_group_id}.
    organizationLevel Boolean
    Whether the metadata feed is at the organization-level. If true, all changes happened to the entries in the same organization as the feed are published. If false, you must specify a list of projects or a list of entry groups whose entries you want to listen to.The default is false.
    projects List<String>
    The projects whose entries you want to listen to. Must be in the same organization as the feed. Must be in the format: projects/{project_id_or_number}.

    Import

    MetadataFeed can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{location}}/metadataFeeds/{{metadata_feed_id}}
    • {{project}}/{{location}}/{{metadata_feed_id}}
    • {{location}}/{{metadata_feed_id}}

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

    $ pulumi import gcp:dataplex/metadataFeed:MetadataFeed default projects/{{project}}/locations/{{location}}/metadataFeeds/{{metadata_feed_id}}
$ pulumi import gcp:dataplex/metadataFeed:MetadataFeed default {{project}}/{{location}}/{{metadata_feed_id}}
$ pulumi import gcp:dataplex/metadataFeed:MetadataFeed default {{location}}/{{metadata_feed_id}}

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Google Cloud (GCP) Classic pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Viewing docs for Google Cloud v9.30.0
    published on Monday, Jul 13, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-gcp

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial