1. Packages
  2. Packages
  3. Google Cloud (GCP) Classic
  4. API Docs
  5. datalineage
  6. Config
Viewing docs for Google Cloud v9.22.0
published on Friday, May 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

gcp.datalineage.Config

gcp logo
Viewing docs for Google Cloud v9.22.0
published on Friday, May 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

    Configuration for Data Lineage.

    Defines configuration options for Lineage customers to control behavior of lineage systems.

    To get more information about Config, see:

    Example Usage

    Data Lineage Config Project

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

const _default = new gcp.datalineage.Config("default", {
    parent: "projects/my-project-name",
    location: "global",
    ingestion: {
        rules: [{
            integrationSelector: {
                integration: "DATAPROC",
            },
            lineageEnablement: {
                enabled: true,
            },
        }],
    },
});

    import pulumi
import pulumi_gcp as gcp

default = gcp.datalineage.Config("default",
    parent="projects/my-project-name",
    location="global",
    ingestion={
        "rules": [{
            "integration_selector": {
                "integration": "DATAPROC",
            },
            "lineage_enablement": {
                "enabled": True,
            },
        }],
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datalineage.NewConfig(ctx, "default", &datalineage.ConfigArgs{
			Parent:   pulumi.String("projects/my-project-name"),
			Location: pulumi.String("global"),
			Ingestion: &datalineage.ConfigIngestionArgs{
				Rules: datalineage.ConfigIngestionRuleArray{
					&datalineage.ConfigIngestionRuleArgs{
						IntegrationSelector: &datalineage.ConfigIngestionRuleIntegrationSelectorArgs{
							Integration: pulumi.String("DATAPROC"),
						},
						LineageEnablement: &datalineage.ConfigIngestionRuleLineageEnablementArgs{
							Enabled: pulumi.Bool(true),
						},
					},
				},
			},
		})
		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 @default = new Gcp.DataLineage.Config("default", new()
    {
        Parent = "projects/my-project-name",
        Location = "global",
        Ingestion = new Gcp.DataLineage.Inputs.ConfigIngestionArgs
        {
            Rules = new[]
            {
                new Gcp.DataLineage.Inputs.ConfigIngestionRuleArgs
                {
                    IntegrationSelector = new Gcp.DataLineage.Inputs.ConfigIngestionRuleIntegrationSelectorArgs
                    {
                        Integration = "DATAPROC",
                    },
                    LineageEnablement = new Gcp.DataLineage.Inputs.ConfigIngestionRuleLineageEnablementArgs
                    {
                        Enabled = true,
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.datalineage.Config;
import com.pulumi.gcp.datalineage.ConfigArgs;
import com.pulumi.gcp.datalineage.inputs.ConfigIngestionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = new Config("default", ConfigArgs.builder()
            .parent("projects/my-project-name")
            .location("global")
            .ingestion(ConfigIngestionArgs.builder()
                .rules(ConfigIngestionRuleArgs.builder()
                    .integrationSelector(ConfigIngestionRuleIntegrationSelectorArgs.builder()
                        .integration("DATAPROC")
                        .build())
                    .lineageEnablement(ConfigIngestionRuleLineageEnablementArgs.builder()
                        .enabled(true)
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  default:
    type: gcp:datalineage:Config
    properties:
      parent: projects/my-project-name
      location: global
      ingestion:
        rules:
          - integrationSelector:
              integration: DATAPROC
            lineageEnablement:
              enabled: true

    Data Lineage Config Folder

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

const integration = new gcp.organizations.Folder("integration", {
    displayName: "config-f",
    parent: "organizations/123456789",
    deletionProtection: false,
});
const datalineageAdmin = new gcp.folder.IAMMember("datalineage_admin", {
    folder: integration.folderId,
    role: "roles/datalineage.admin",
    member: "serviceAccount:my@service-account.com",
});
const waitForFolderIam = new time.Sleep("wait_for_folder_iam", {createDuration: "60s"}, {
    dependsOn: [datalineageAdmin],
});
const _default = new gcp.datalineage.Config("default", {
    parent: integration.name,
    location: "global",
    ingestion: {
        rules: [{
            integrationSelector: {
                integration: "DATAPROC",
            },
            lineageEnablement: {
                enabled: true,
            },
        }],
    },
}, {
    dependsOn: [waitForFolderIam],
});

    import pulumi
import pulumi_gcp as gcp
import pulumiverse_time as time

integration = gcp.organizations.Folder("integration",
    display_name="config-f",
    parent="organizations/123456789",
    deletion_protection=False)
datalineage_admin = gcp.folder.IAMMember("datalineage_admin",
    folder=integration.folder_id,
    role="roles/datalineage.admin",
    member="serviceAccount:my@service-account.com")
wait_for_folder_iam = time.Sleep("wait_for_folder_iam", create_duration="60s",
opts = pulumi.ResourceOptions(depends_on=[datalineage_admin]))
default = gcp.datalineage.Config("default",
    parent=integration.name,
    location="global",
    ingestion={
        "rules": [{
            "integration_selector": {
                "integration": "DATAPROC",
            },
            "lineage_enablement": {
                "enabled": True,
            },
        }],
    },
    opts = pulumi.ResourceOptions(depends_on=[wait_for_folder_iam]))

    package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/datalineage"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/folder"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-time/sdk/go/time"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		integration, err := organizations.NewFolder(ctx, "integration", &organizations.FolderArgs{
			DisplayName:        pulumi.String("config-f"),
			Parent:             pulumi.String("organizations/123456789"),
			DeletionProtection: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		datalineageAdmin, err := folder.NewIAMMember(ctx, "datalineage_admin", &folder.IAMMemberArgs{
			Folder: integration.FolderId,
			Role:   pulumi.String("roles/datalineage.admin"),
			Member: pulumi.String("serviceAccount:my@service-account.com"),
		})
		if err != nil {
			return err
		}
		waitForFolderIam, err := time.NewSleep(ctx, "wait_for_folder_iam", &time.SleepArgs{
			CreateDuration: pulumi.String("60s"),
		}, pulumi.DependsOn([]pulumi.Resource{
			datalineageAdmin,
		}))
		if err != nil {
			return err
		}
		_, err = datalineage.NewConfig(ctx, "default", &datalineage.ConfigArgs{
			Parent:   integration.Name,
			Location: pulumi.String("global"),
			Ingestion: &datalineage.ConfigIngestionArgs{
				Rules: datalineage.ConfigIngestionRuleArray{
					&datalineage.ConfigIngestionRuleArgs{
						IntegrationSelector: &datalineage.ConfigIngestionRuleIntegrationSelectorArgs{
							Integration: pulumi.String("DATAPROC"),
						},
						LineageEnablement: &datalineage.ConfigIngestionRuleLineageEnablementArgs{
							Enabled: pulumi.Bool(true),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			waitForFolderIam,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var integration = new Gcp.Organizations.Folder("integration", new()
    {
        DisplayName = "config-f",
        Parent = "organizations/123456789",
        DeletionProtection = false,
    });

    var datalineageAdmin = new Gcp.Folder.IAMMember("datalineage_admin", new()
    {
        Folder = integration.FolderId,
        Role = "roles/datalineage.admin",
        Member = "serviceAccount:my@service-account.com",
    });

    var waitForFolderIam = new Time.Index.Sleep("wait_for_folder_iam", new()
    {
        CreateDuration = "60s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            datalineageAdmin,
        },
    });

    var @default = new Gcp.DataLineage.Config("default", new()
    {
        Parent = integration.Name,
        Location = "global",
        Ingestion = new Gcp.DataLineage.Inputs.ConfigIngestionArgs
        {
            Rules = new[]
            {
                new Gcp.DataLineage.Inputs.ConfigIngestionRuleArgs
                {
                    IntegrationSelector = new Gcp.DataLineage.Inputs.ConfigIngestionRuleIntegrationSelectorArgs
                    {
                        Integration = "DATAPROC",
                    },
                    LineageEnablement = new Gcp.DataLineage.Inputs.ConfigIngestionRuleLineageEnablementArgs
                    {
                        Enabled = true,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            waitForFolderIam,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Folder;
import com.pulumi.gcp.organizations.FolderArgs;
import com.pulumi.gcp.folder.IAMMember;
import com.pulumi.gcp.folder.IAMMemberArgs;
import com.pulumiverse.time.Sleep;
import com.pulumiverse.time.SleepArgs;
import com.pulumi.gcp.datalineage.Config;
import com.pulumi.gcp.datalineage.ConfigArgs;
import com.pulumi.gcp.datalineage.inputs.ConfigIngestionArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var integration = new Folder("integration", FolderArgs.builder()
            .displayName("config-f")
            .parent("organizations/123456789")
            .deletionProtection(false)
            .build());

        var datalineageAdmin = new IAMMember("datalineageAdmin", IAMMemberArgs.builder()
            .folder(integration.folderId())
            .role("roles/datalineage.admin")
            .member("serviceAccount:my@service-account.com")
            .build());

        var waitForFolderIam = new Sleep("waitForFolderIam", SleepArgs.builder()
            .createDuration("60s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(datalineageAdmin)
                .build());

        var default_ = new Config("default", ConfigArgs.builder()
            .parent(integration.name())
            .location("global")
            .ingestion(ConfigIngestionArgs.builder()
                .rules(ConfigIngestionRuleArgs.builder()
                    .integrationSelector(ConfigIngestionRuleIntegrationSelectorArgs.builder()
                        .integration("DATAPROC")
                        .build())
                    .lineageEnablement(ConfigIngestionRuleLineageEnablementArgs.builder()
                        .enabled(true)
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(waitForFolderIam)
                .build());

    }
}

    resources:
  default:
    type: gcp:datalineage:Config
    properties:
      parent: ${integration.name}
      location: global
      ingestion:
        rules:
          - integrationSelector:
              integration: DATAPROC
            lineageEnablement:
              enabled: true
    options:
      dependsOn:
        - ${waitForFolderIam}
  waitForFolderIam:
    type: time:Sleep
    name: wait_for_folder_iam
    properties:
      createDuration: 60s
    options:
      dependsOn:
        - ${datalineageAdmin}
  integration:
    type: gcp:organizations:Folder
    properties:
      displayName: config-f
      parent: organizations/123456789
      deletionProtection: false
  datalineageAdmin:
    type: gcp:folder:IAMMember
    name: datalineage_admin
    properties:
      folder: ${integration.folderId}
      role: roles/datalineage.admin
      member: serviceAccount:my@service-account.com

    Data Lineage Config Organization

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

const _default = new gcp.datalineage.Config("default", {
    parent: "organizations/123456789",
    location: "global",
    ingestion: {
        rules: [{
            integrationSelector: {
                integration: "LOOKER_CORE",
            },
            lineageEnablement: {
                enabled: true,
            },
        }],
    },
});

    import pulumi
import pulumi_gcp as gcp

default = gcp.datalineage.Config("default",
    parent="organizations/123456789",
    location="global",
    ingestion={
        "rules": [{
            "integration_selector": {
                "integration": "LOOKER_CORE",
            },
            "lineage_enablement": {
                "enabled": True,
            },
        }],
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datalineage.NewConfig(ctx, "default", &datalineage.ConfigArgs{
			Parent:   pulumi.String("organizations/123456789"),
			Location: pulumi.String("global"),
			Ingestion: &datalineage.ConfigIngestionArgs{
				Rules: datalineage.ConfigIngestionRuleArray{
					&datalineage.ConfigIngestionRuleArgs{
						IntegrationSelector: &datalineage.ConfigIngestionRuleIntegrationSelectorArgs{
							Integration: pulumi.String("LOOKER_CORE"),
						},
						LineageEnablement: &datalineage.ConfigIngestionRuleLineageEnablementArgs{
							Enabled: pulumi.Bool(true),
						},
					},
				},
			},
		})
		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 @default = new Gcp.DataLineage.Config("default", new()
    {
        Parent = "organizations/123456789",
        Location = "global",
        Ingestion = new Gcp.DataLineage.Inputs.ConfigIngestionArgs
        {
            Rules = new[]
            {
                new Gcp.DataLineage.Inputs.ConfigIngestionRuleArgs
                {
                    IntegrationSelector = new Gcp.DataLineage.Inputs.ConfigIngestionRuleIntegrationSelectorArgs
                    {
                        Integration = "LOOKER_CORE",
                    },
                    LineageEnablement = new Gcp.DataLineage.Inputs.ConfigIngestionRuleLineageEnablementArgs
                    {
                        Enabled = true,
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.datalineage.Config;
import com.pulumi.gcp.datalineage.ConfigArgs;
import com.pulumi.gcp.datalineage.inputs.ConfigIngestionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = new Config("default", ConfigArgs.builder()
            .parent("organizations/123456789")
            .location("global")
            .ingestion(ConfigIngestionArgs.builder()
                .rules(ConfigIngestionRuleArgs.builder()
                    .integrationSelector(ConfigIngestionRuleIntegrationSelectorArgs.builder()
                        .integration("LOOKER_CORE")
                        .build())
                    .lineageEnablement(ConfigIngestionRuleLineageEnablementArgs.builder()
                        .enabled(true)
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  default:
    type: gcp:datalineage:Config
    properties:
      parent: organizations/123456789
      location: global
      ingestion:
        rules:
          - integrationSelector:
              integration: LOOKER_CORE
            lineageEnablement:
              enabled: true

    Create Config Resource

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

    Constructor syntax

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

@overload
def Config(resource_name: str,
           opts: Optional[ResourceOptions] = None,
           ingestion: Optional[ConfigIngestionArgs] = None,
           location: Optional[str] = None,
           parent: Optional[str] = None)
    func NewConfig(ctx *Context, name string, args ConfigArgs, opts ...ResourceOption) (*Config, error)
    public Config(string name, ConfigArgs args, CustomResourceOptions? opts = null)
    public Config(String name, ConfigArgs args)
public Config(String name, ConfigArgs args, CustomResourceOptions options)

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

    Parameters

    name string
    The unique name of the resource.
    args ConfigArgs
    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 ConfigArgs
    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 ConfigArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ConfigArgs
    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 gcpConfigResource = new Gcp.DataLineage.Config("gcpConfigResource", new()
{
    Ingestion = new Gcp.DataLineage.Inputs.ConfigIngestionArgs
    {
        Rules = new[]
        {
            new Gcp.DataLineage.Inputs.ConfigIngestionRuleArgs
            {
                IntegrationSelector = new Gcp.DataLineage.Inputs.ConfigIngestionRuleIntegrationSelectorArgs
                {
                    Integration = "string",
                },
                LineageEnablement = new Gcp.DataLineage.Inputs.ConfigIngestionRuleLineageEnablementArgs
                {
                    Enabled = false,
                },
            },
        },
    },
    Location = "string",
    Parent = "string",
});

    example, err := datalineage.NewConfig(ctx, "gcpConfigResource", &datalineage.ConfigArgs{
	Ingestion: &datalineage.ConfigIngestionArgs{
		Rules: datalineage.ConfigIngestionRuleArray{
			&datalineage.ConfigIngestionRuleArgs{
				IntegrationSelector: &datalineage.ConfigIngestionRuleIntegrationSelectorArgs{
					Integration: pulumi.String("string"),
				},
				LineageEnablement: &datalineage.ConfigIngestionRuleLineageEnablementArgs{
					Enabled: pulumi.Bool(false),
				},
			},
		},
	},
	Location: pulumi.String("string"),
	Parent:   pulumi.String("string"),
})

    var gcpConfigResource = new com.pulumi.gcp.datalineage.Config("gcpConfigResource", com.pulumi.gcp.datalineage.ConfigArgs.builder()
    .ingestion(ConfigIngestionArgs.builder()
        .rules(ConfigIngestionRuleArgs.builder()
            .integrationSelector(ConfigIngestionRuleIntegrationSelectorArgs.builder()
                .integration("string")
                .build())
            .lineageEnablement(ConfigIngestionRuleLineageEnablementArgs.builder()
                .enabled(false)
                .build())
            .build())
        .build())
    .location("string")
    .parent("string")
    .build());

    gcp_config_resource = gcp.datalineage.Config("gcpConfigResource",
    ingestion={
        "rules": [{
            "integration_selector": {
                "integration": "string",
            },
            "lineage_enablement": {
                "enabled": False,
            },
        }],
    },
    location="string",
    parent="string")

    const gcpConfigResource = new gcp.datalineage.Config("gcpConfigResource", {
    ingestion: {
        rules: [{
            integrationSelector: {
                integration: "string",
            },
            lineageEnablement: {
                enabled: false,
            },
        }],
    },
    location: "string",
    parent: "string",
});

    type: gcp:datalineage:Config
properties:
    ingestion:
        rules:
            - integrationSelector:
                integration: string
              lineageEnablement:
                enabled: false
    location: string
    parent: string

    Config 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 Config resource accepts the following input properties:

    Ingestion ConfigIngestion
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    Location string
    The region of the data lineage configuration for integration.
    Parent string
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    Ingestion ConfigIngestionArgs
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    Location string
    The region of the data lineage configuration for integration.
    Parent string
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    ingestion ConfigIngestion
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location String
    The region of the data lineage configuration for integration.
    parent String
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    ingestion ConfigIngestion
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location string
    The region of the data lineage configuration for integration.
    parent string
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    ingestion ConfigIngestionArgs
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location str
    The region of the data lineage configuration for integration.
    parent str
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    ingestion Property Map
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location String
    The region of the data lineage configuration for integration.
    parent String
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.

    Outputs

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

    Etag string
    Used for optimistic concurrency control when patching config.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    Etag string
    Used for optimistic concurrency control when patching config.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    etag String
    Used for optimistic concurrency control when patching config.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    etag string
    Used for optimistic concurrency control when patching config.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    etag str
    Used for optimistic concurrency control when patching config.
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    etag String
    Used for optimistic concurrency control when patching config.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.

    Look up Existing Config Resource

    Get an existing Config 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?: ConfigState, opts?: CustomResourceOptions): Config
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        etag: Optional[str] = None,
        ingestion: Optional[ConfigIngestionArgs] = None,
        location: Optional[str] = None,
        name: Optional[str] = None,
        parent: Optional[str] = None) -> Config
    func GetConfig(ctx *Context, name string, id IDInput, state *ConfigState, opts ...ResourceOption) (*Config, error)
    public static Config Get(string name, Input<string> id, ConfigState? state, CustomResourceOptions? opts = null)
    public static Config get(String name, Output<String> id, ConfigState state, CustomResourceOptions options)
    resources:  _:    type: gcp:datalineage:Config    get:      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:
    Etag string
    Used for optimistic concurrency control when patching config.
    Ingestion ConfigIngestion
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    Location string
    The region of the data lineage configuration for integration.
    Name string
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    Parent string
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    Etag string
    Used for optimistic concurrency control when patching config.
    Ingestion ConfigIngestionArgs
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    Location string
    The region of the data lineage configuration for integration.
    Name string
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    Parent string
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    etag String
    Used for optimistic concurrency control when patching config.
    ingestion ConfigIngestion
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location String
    The region of the data lineage configuration for integration.
    name String
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    parent String
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    etag string
    Used for optimistic concurrency control when patching config.
    ingestion ConfigIngestion
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location string
    The region of the data lineage configuration for integration.
    name string
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    parent string
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    etag str
    Used for optimistic concurrency control when patching config.
    ingestion ConfigIngestionArgs
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location str
    The region of the data lineage configuration for integration.
    name str
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    parent str
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.
    etag String
    Used for optimistic concurrency control when patching config.
    ingestion Property Map
    Defines how Lineage should be ingested for this resource. Structure is documented below.
    location String
    The region of the data lineage configuration for integration.
    name String
    Identifier. The resource name of the config. Format: organizations/{organization_id}/locations/{location}/config, folders/{folder_id}/locations/{location}/config, projects/{project_id}/locations/{location}/config, or projects/{project_number}/locations/{location}/config.
    parent String
    Parent scope for the config. Format: projects/{project-id|project-number} or folders/{folder-number} or organizations/{organization-number}.

    Supporting Types

    ConfigIngestion, ConfigIngestionArgs

    Rules List<ConfigIngestionRule>
    List of ingestion rules for Data Lineage ingestion. Structure is documented below.
    Rules []ConfigIngestionRule
    List of ingestion rules for Data Lineage ingestion. Structure is documented below.
    rules List<ConfigIngestionRule>
    List of ingestion rules for Data Lineage ingestion. Structure is documented below.
    rules ConfigIngestionRule[]
    List of ingestion rules for Data Lineage ingestion. Structure is documented below.
    rules Sequence[ConfigIngestionRule]
    List of ingestion rules for Data Lineage ingestion. Structure is documented below.
    rules List<Property Map>
    List of ingestion rules for Data Lineage ingestion. Structure is documented below.

    ConfigIngestionRule, ConfigIngestionRuleArgs

    IntegrationSelector ConfigIngestionRuleIntegrationSelector
    Selects which integration this rule applies to. Structure is documented below.
    LineageEnablement ConfigIngestionRuleLineageEnablement
    Configures lineage ingestion enablement for this scope. Structure is documented below.
    IntegrationSelector ConfigIngestionRuleIntegrationSelector
    Selects which integration this rule applies to. Structure is documented below.
    LineageEnablement ConfigIngestionRuleLineageEnablement
    Configures lineage ingestion enablement for this scope. Structure is documented below.
    integrationSelector ConfigIngestionRuleIntegrationSelector
    Selects which integration this rule applies to. Structure is documented below.
    lineageEnablement ConfigIngestionRuleLineageEnablement
    Configures lineage ingestion enablement for this scope. Structure is documented below.
    integrationSelector ConfigIngestionRuleIntegrationSelector
    Selects which integration this rule applies to. Structure is documented below.
    lineageEnablement ConfigIngestionRuleLineageEnablement
    Configures lineage ingestion enablement for this scope. Structure is documented below.
    integration_selector ConfigIngestionRuleIntegrationSelector
    Selects which integration this rule applies to. Structure is documented below.
    lineage_enablement ConfigIngestionRuleLineageEnablement
    Configures lineage ingestion enablement for this scope. Structure is documented below.
    integrationSelector Property Map
    Selects which integration this rule applies to. Structure is documented below.
    lineageEnablement Property Map
    Configures lineage ingestion enablement for this scope. Structure is documented below.

    ConfigIngestionRuleIntegrationSelector, ConfigIngestionRuleIntegrationSelectorArgs

    Integration string
    Integration to which the rule applies. Possible values are: DATAPROC, LOOKER_CORE.
    Integration string
    Integration to which the rule applies. Possible values are: DATAPROC, LOOKER_CORE.
    integration String
    Integration to which the rule applies. Possible values are: DATAPROC, LOOKER_CORE.
    integration string
    Integration to which the rule applies. Possible values are: DATAPROC, LOOKER_CORE.
    integration str
    Integration to which the rule applies. Possible values are: DATAPROC, LOOKER_CORE.
    integration String
    Integration to which the rule applies. Possible values are: DATAPROC, LOOKER_CORE.

    ConfigIngestionRuleLineageEnablement, ConfigIngestionRuleLineageEnablementArgs

    Enabled bool
    Whether ingestion of lineage should be enabled.
    Enabled bool
    Whether ingestion of lineage should be enabled.
    enabled Boolean
    Whether ingestion of lineage should be enabled.
    enabled boolean
    Whether ingestion of lineage should be enabled.
    enabled bool
    Whether ingestion of lineage should be enabled.
    enabled Boolean
    Whether ingestion of lineage should be enabled.

    Import

    Config can be imported using any of these accepted formats:

    • {{parent}}/locations/{{location}}/config

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

    $ pulumi import gcp:datalineage/config:Config default {{parent}}/locations/{{location}}/config

    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.22.0
    published on Friday, May 1, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-gcp
      Try Pulumi Cloud free. Your team will thank you.