1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. dataform
  5. Config
Viewing docs for Google Cloud v9.15.0
published on Thursday, Mar 12, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

gcp.dataform.Config

gcp logo
Viewing docs for Google Cloud v9.15.0
published on Thursday, Mar 12, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

    Config is a singleton resource used to configure the default Dataform settings for a specified location.

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

    To get more information about Config, see:

    Example Usage

    Dataform Config With Kms Key

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

const project = new gcp.organizations.Project("project", {
    name: "project-1",
    projectId: "project-1",
    orgId: "123456789",
    billingAccount: "000000-0000000-0000000-000000",
    deletionPolicy: "DELETE",
});
// Enable Cloud Key KMS API
const cloudkmsApi = new gcp.projects.Service("cloudkms_api", {
    project: project.projectId,
    service: "cloudkms.googleapis.com",
    disableOnDestroy: false,
});
// Enable Dataform API
const dataformApi = new gcp.projects.Service("dataform_api", {
    project: project.projectId,
    service: "dataform.googleapis.com",
    disableOnDestroy: false,
});
// Add a sleep to wait for IAM propagation after API enablement
const waitForDataformApi = new time.Sleep("wait_for_dataform_api", {createDuration: "30s"}, {
    dependsOn: [dataformApi],
});
// Retrieve the Dataform service identity
const dataformSa = new gcp.projects.ServiceIdentity("dataform_sa", {
    project: project.projectId,
    service: "dataform.googleapis.com",
});
const keyring = new gcp.kms.KeyRing("keyring", {
    project: project.projectId,
    name: "example-key-ring",
    location: "us-central1",
}, {
    dependsOn: [cloudkmsApi],
});
const exampleKey = new gcp.kms.CryptoKey("example_key", {
    name: "example-crypto-key-name",
    keyRing: keyring.id,
});
// Grant the Encrypter/Decrypter role to the Dataform service agent on the KMS key
const cryptoKeyBinding = new gcp.kms.CryptoKeyIAMMember("crypto_key_binding", {
    cryptoKeyId: exampleKey.id,
    role: "roles/cloudkms.cryptoKeyEncrypterDecrypter",
    member: dataformSa.member,
});
// Config with KMS key provided
const config = new gcp.dataform.Config("config", {
    region: "us-central1",
    defaultKmsKeyName: exampleKey.id,
    project: project.projectId,
}, {
    dependsOn: [
        cryptoKeyBinding,
        waitForDataformApi,
    ],
});

    import pulumi
import pulumi_gcp as gcp
import pulumiverse_time as time

project = gcp.organizations.Project("project",
    name="project-1",
    project_id="project-1",
    org_id="123456789",
    billing_account="000000-0000000-0000000-000000",
    deletion_policy="DELETE")
# Enable Cloud Key KMS API
cloudkms_api = gcp.projects.Service("cloudkms_api",
    project=project.project_id,
    service="cloudkms.googleapis.com",
    disable_on_destroy=False)
# Enable Dataform API
dataform_api = gcp.projects.Service("dataform_api",
    project=project.project_id,
    service="dataform.googleapis.com",
    disable_on_destroy=False)
# Add a sleep to wait for IAM propagation after API enablement
wait_for_dataform_api = time.Sleep("wait_for_dataform_api", create_duration="30s",
opts = pulumi.ResourceOptions(depends_on=[dataform_api]))
# Retrieve the Dataform service identity
dataform_sa = gcp.projects.ServiceIdentity("dataform_sa",
    project=project.project_id,
    service="dataform.googleapis.com")
keyring = gcp.kms.KeyRing("keyring",
    project=project.project_id,
    name="example-key-ring",
    location="us-central1",
    opts = pulumi.ResourceOptions(depends_on=[cloudkms_api]))
example_key = gcp.kms.CryptoKey("example_key",
    name="example-crypto-key-name",
    key_ring=keyring.id)
# Grant the Encrypter/Decrypter role to the Dataform service agent on the KMS key
crypto_key_binding = gcp.kms.CryptoKeyIAMMember("crypto_key_binding",
    crypto_key_id=example_key.id,
    role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
    member=dataform_sa.member)
# Config with KMS key provided
config = gcp.dataform.Config("config",
    region="us-central1",
    default_kms_key_name=example_key.id,
    project=project.project_id,
    opts = pulumi.ResourceOptions(depends_on=[
            crypto_key_binding,
            wait_for_dataform_api,
        ]))

    package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataform"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/kms"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/projects"
	"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 {
		project, err := organizations.NewProject(ctx, "project", &organizations.ProjectArgs{
			Name:           pulumi.String("project-1"),
			ProjectId:      pulumi.String("project-1"),
			OrgId:          pulumi.String("123456789"),
			BillingAccount: pulumi.String("000000-0000000-0000000-000000"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		// Enable Cloud Key KMS API
		cloudkmsApi, err := projects.NewService(ctx, "cloudkms_api", &projects.ServiceArgs{
			Project:          project.ProjectId,
			Service:          pulumi.String("cloudkms.googleapis.com"),
			DisableOnDestroy: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// Enable Dataform API
		dataformApi, err := projects.NewService(ctx, "dataform_api", &projects.ServiceArgs{
			Project:          project.ProjectId,
			Service:          pulumi.String("dataform.googleapis.com"),
			DisableOnDestroy: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// Add a sleep to wait for IAM propagation after API enablement
		waitForDataformApi, err := time.NewSleep(ctx, "wait_for_dataform_api", &time.SleepArgs{
			CreateDuration: pulumi.String("30s"),
		}, pulumi.DependsOn([]pulumi.Resource{
			dataformApi,
		}))
		if err != nil {
			return err
		}
		// Retrieve the Dataform service identity
		dataformSa, err := projects.NewServiceIdentity(ctx, "dataform_sa", &projects.ServiceIdentityArgs{
			Project: project.ProjectId,
			Service: pulumi.String("dataform.googleapis.com"),
		})
		if err != nil {
			return err
		}
		keyring, err := kms.NewKeyRing(ctx, "keyring", &kms.KeyRingArgs{
			Project:  project.ProjectId,
			Name:     pulumi.String("example-key-ring"),
			Location: pulumi.String("us-central1"),
		}, pulumi.DependsOn([]pulumi.Resource{
			cloudkmsApi,
		}))
		if err != nil {
			return err
		}
		exampleKey, err := kms.NewCryptoKey(ctx, "example_key", &kms.CryptoKeyArgs{
			Name:    pulumi.String("example-crypto-key-name"),
			KeyRing: keyring.ID(),
		})
		if err != nil {
			return err
		}
		// Grant the Encrypter/Decrypter role to the Dataform service agent on the KMS key
		cryptoKeyBinding, err := kms.NewCryptoKeyIAMMember(ctx, "crypto_key_binding", &kms.CryptoKeyIAMMemberArgs{
			CryptoKeyId: exampleKey.ID(),
			Role:        pulumi.String("roles/cloudkms.cryptoKeyEncrypterDecrypter"),
			Member:      dataformSa.Member,
		})
		if err != nil {
			return err
		}
		// Config with KMS key provided
		_, err = dataform.NewConfig(ctx, "config", &dataform.ConfigArgs{
			Region:            pulumi.String("us-central1"),
			DefaultKmsKeyName: exampleKey.ID(),
			Project:           project.ProjectId,
		}, pulumi.DependsOn([]pulumi.Resource{
			cryptoKeyBinding,
			waitForDataformApi,
		}))
		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 project = new Gcp.Organizations.Project("project", new()
    {
        Name = "project-1",
        ProjectId = "project-1",
        OrgId = "123456789",
        BillingAccount = "000000-0000000-0000000-000000",
        DeletionPolicy = "DELETE",
    });

    // Enable Cloud Key KMS API
    var cloudkmsApi = new Gcp.Projects.Service("cloudkms_api", new()
    {
        Project = project.ProjectId,
        ServiceName = "cloudkms.googleapis.com",
        DisableOnDestroy = false,
    });

    // Enable Dataform API
    var dataformApi = new Gcp.Projects.Service("dataform_api", new()
    {
        Project = project.ProjectId,
        ServiceName = "dataform.googleapis.com",
        DisableOnDestroy = false,
    });

    // Add a sleep to wait for IAM propagation after API enablement
    var waitForDataformApi = new Time.Sleep("wait_for_dataform_api", new()
    {
        CreateDuration = "30s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            dataformApi,
        },
    });

    // Retrieve the Dataform service identity
    var dataformSa = new Gcp.Projects.ServiceIdentity("dataform_sa", new()
    {
        Project = project.ProjectId,
        Service = "dataform.googleapis.com",
    });

    var keyring = new Gcp.Kms.KeyRing("keyring", new()
    {
        Project = project.ProjectId,
        Name = "example-key-ring",
        Location = "us-central1",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            cloudkmsApi,
        },
    });

    var exampleKey = new Gcp.Kms.CryptoKey("example_key", new()
    {
        Name = "example-crypto-key-name",
        KeyRing = keyring.Id,
    });

    // Grant the Encrypter/Decrypter role to the Dataform service agent on the KMS key
    var cryptoKeyBinding = new Gcp.Kms.CryptoKeyIAMMember("crypto_key_binding", new()
    {
        CryptoKeyId = exampleKey.Id,
        Role = "roles/cloudkms.cryptoKeyEncrypterDecrypter",
        Member = dataformSa.Member,
    });

    // Config with KMS key provided
    var config = new Gcp.Dataform.Config("config", new()
    {
        Region = "us-central1",
        DefaultKmsKeyName = exampleKey.Id,
        Project = project.ProjectId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            cryptoKeyBinding,
            waitForDataformApi,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumiverse.time.Sleep;
import com.pulumiverse.time.SleepArgs;
import com.pulumi.gcp.projects.ServiceIdentity;
import com.pulumi.gcp.projects.ServiceIdentityArgs;
import com.pulumi.gcp.kms.KeyRing;
import com.pulumi.gcp.kms.KeyRingArgs;
import com.pulumi.gcp.kms.CryptoKey;
import com.pulumi.gcp.kms.CryptoKeyArgs;
import com.pulumi.gcp.kms.CryptoKeyIAMMember;
import com.pulumi.gcp.kms.CryptoKeyIAMMemberArgs;
import com.pulumi.gcp.dataform.Config;
import com.pulumi.gcp.dataform.ConfigArgs;
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 project = new Project("project", ProjectArgs.builder()
            .name("project-1")
            .projectId("project-1")
            .orgId("123456789")
            .billingAccount("000000-0000000-0000000-000000")
            .deletionPolicy("DELETE")
            .build());

        // Enable Cloud Key KMS API
        var cloudkmsApi = new Service("cloudkmsApi", ServiceArgs.builder()
            .project(project.projectId())
            .service("cloudkms.googleapis.com")
            .disableOnDestroy(false)
            .build());

        // Enable Dataform API
        var dataformApi = new Service("dataformApi", ServiceArgs.builder()
            .project(project.projectId())
            .service("dataform.googleapis.com")
            .disableOnDestroy(false)
            .build());

        // Add a sleep to wait for IAM propagation after API enablement
        var waitForDataformApi = new Sleep("waitForDataformApi", SleepArgs.builder()
            .createDuration("30s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(dataformApi)
                .build());

        // Retrieve the Dataform service identity
        var dataformSa = new ServiceIdentity("dataformSa", ServiceIdentityArgs.builder()
            .project(project.projectId())
            .service("dataform.googleapis.com")
            .build());

        var keyring = new KeyRing("keyring", KeyRingArgs.builder()
            .project(project.projectId())
            .name("example-key-ring")
            .location("us-central1")
            .build(), CustomResourceOptions.builder()
                .dependsOn(cloudkmsApi)
                .build());

        var exampleKey = new CryptoKey("exampleKey", CryptoKeyArgs.builder()
            .name("example-crypto-key-name")
            .keyRing(keyring.id())
            .build());

        // Grant the Encrypter/Decrypter role to the Dataform service agent on the KMS key
        var cryptoKeyBinding = new CryptoKeyIAMMember("cryptoKeyBinding", CryptoKeyIAMMemberArgs.builder()
            .cryptoKeyId(exampleKey.id())
            .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
            .member(dataformSa.member())
            .build());

        // Config with KMS key provided
        var config = new Config("config", ConfigArgs.builder()
            .region("us-central1")
            .defaultKmsKeyName(exampleKey.id())
            .project(project.projectId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    cryptoKeyBinding,
                    waitForDataformApi)
                .build());

    }
}

    resources:
  project:
    type: gcp:organizations:Project
    properties:
      name: project-1
      projectId: project-1
      orgId: '123456789'
      billingAccount: 000000-0000000-0000000-000000
      deletionPolicy: DELETE
  # Enable Cloud Key KMS API
  cloudkmsApi:
    type: gcp:projects:Service
    name: cloudkms_api
    properties:
      project: ${project.projectId}
      service: cloudkms.googleapis.com
      disableOnDestroy: false
  # Enable Dataform API
  dataformApi:
    type: gcp:projects:Service
    name: dataform_api
    properties:
      project: ${project.projectId}
      service: dataform.googleapis.com
      disableOnDestroy: false
  # Add a sleep to wait for IAM propagation after API enablement
  waitForDataformApi:
    type: time:Sleep
    name: wait_for_dataform_api
    properties:
      createDuration: 30s
    options:
      dependsOn:
        - ${dataformApi}
  # Retrieve the Dataform service identity
  dataformSa:
    type: gcp:projects:ServiceIdentity
    name: dataform_sa
    properties:
      project: ${project.projectId}
      service: dataform.googleapis.com
  keyring:
    type: gcp:kms:KeyRing
    properties:
      project: ${project.projectId}
      name: example-key-ring
      location: us-central1
    options:
      dependsOn:
        - ${cloudkmsApi}
  exampleKey:
    type: gcp:kms:CryptoKey
    name: example_key
    properties:
      name: example-crypto-key-name
      keyRing: ${keyring.id}
  # Grant the Encrypter/Decrypter role to the Dataform service agent on the KMS key
  cryptoKeyBinding:
    type: gcp:kms:CryptoKeyIAMMember
    name: crypto_key_binding
    properties:
      cryptoKeyId: ${exampleKey.id}
      role: roles/cloudkms.cryptoKeyEncrypterDecrypter
      member: ${dataformSa.member}
  # Config with KMS key provided
  config:
    type: gcp:dataform:Config
    properties:
      region: us-central1
      defaultKmsKeyName: ${exampleKey.id}
      project: ${project.projectId}
    options:
      dependsOn:
        - ${cryptoKeyBinding}
        - ${waitForDataformApi}

    Dataform Config Without Kms Key

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

const project = new gcp.organizations.Project("project", {
    name: "project-1",
    projectId: "project-1",
    orgId: "123456789",
    billingAccount: "000000-0000000-0000000-000000",
    deletionPolicy: "DELETE",
});
// Enable Dataform API
const dataformApi = new gcp.projects.Service("dataform_api", {
    project: project.projectId,
    service: "dataform.googleapis.com",
    disableOnDestroy: false,
});
// Add a sleep to wait for IAM propagation after API enablement
const waitForDataformApi = new time.Sleep("wait_for_dataform_api", {createDuration: "30s"}, {
    dependsOn: [dataformApi],
});
// Config without KMS key provided
const config = new gcp.dataform.Config("config", {
    region: "us-central1",
    project: project.projectId,
}, {
    dependsOn: [waitForDataformApi],
});

    import pulumi
import pulumi_gcp as gcp
import pulumiverse_time as time

project = gcp.organizations.Project("project",
    name="project-1",
    project_id="project-1",
    org_id="123456789",
    billing_account="000000-0000000-0000000-000000",
    deletion_policy="DELETE")
# Enable Dataform API
dataform_api = gcp.projects.Service("dataform_api",
    project=project.project_id,
    service="dataform.googleapis.com",
    disable_on_destroy=False)
# Add a sleep to wait for IAM propagation after API enablement
wait_for_dataform_api = time.Sleep("wait_for_dataform_api", create_duration="30s",
opts = pulumi.ResourceOptions(depends_on=[dataform_api]))
# Config without KMS key provided
config = gcp.dataform.Config("config",
    region="us-central1",
    project=project.project_id,
    opts = pulumi.ResourceOptions(depends_on=[wait_for_dataform_api]))

    package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataform"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/projects"
	"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 {
		project, err := organizations.NewProject(ctx, "project", &organizations.ProjectArgs{
			Name:           pulumi.String("project-1"),
			ProjectId:      pulumi.String("project-1"),
			OrgId:          pulumi.String("123456789"),
			BillingAccount: pulumi.String("000000-0000000-0000000-000000"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		// Enable Dataform API
		dataformApi, err := projects.NewService(ctx, "dataform_api", &projects.ServiceArgs{
			Project:          project.ProjectId,
			Service:          pulumi.String("dataform.googleapis.com"),
			DisableOnDestroy: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// Add a sleep to wait for IAM propagation after API enablement
		waitForDataformApi, err := time.NewSleep(ctx, "wait_for_dataform_api", &time.SleepArgs{
			CreateDuration: pulumi.String("30s"),
		}, pulumi.DependsOn([]pulumi.Resource{
			dataformApi,
		}))
		if err != nil {
			return err
		}
		// Config without KMS key provided
		_, err = dataform.NewConfig(ctx, "config", &dataform.ConfigArgs{
			Region:  pulumi.String("us-central1"),
			Project: project.ProjectId,
		}, pulumi.DependsOn([]pulumi.Resource{
			waitForDataformApi,
		}))
		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 project = new Gcp.Organizations.Project("project", new()
    {
        Name = "project-1",
        ProjectId = "project-1",
        OrgId = "123456789",
        BillingAccount = "000000-0000000-0000000-000000",
        DeletionPolicy = "DELETE",
    });

    // Enable Dataform API
    var dataformApi = new Gcp.Projects.Service("dataform_api", new()
    {
        Project = project.ProjectId,
        ServiceName = "dataform.googleapis.com",
        DisableOnDestroy = false,
    });

    // Add a sleep to wait for IAM propagation after API enablement
    var waitForDataformApi = new Time.Sleep("wait_for_dataform_api", new()
    {
        CreateDuration = "30s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            dataformApi,
        },
    });

    // Config without KMS key provided
    var config = new Gcp.Dataform.Config("config", new()
    {
        Region = "us-central1",
        Project = project.ProjectId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            waitForDataformApi,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumiverse.time.Sleep;
import com.pulumiverse.time.SleepArgs;
import com.pulumi.gcp.dataform.Config;
import com.pulumi.gcp.dataform.ConfigArgs;
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 project = new Project("project", ProjectArgs.builder()
            .name("project-1")
            .projectId("project-1")
            .orgId("123456789")
            .billingAccount("000000-0000000-0000000-000000")
            .deletionPolicy("DELETE")
            .build());

        // Enable Dataform API
        var dataformApi = new Service("dataformApi", ServiceArgs.builder()
            .project(project.projectId())
            .service("dataform.googleapis.com")
            .disableOnDestroy(false)
            .build());

        // Add a sleep to wait for IAM propagation after API enablement
        var waitForDataformApi = new Sleep("waitForDataformApi", SleepArgs.builder()
            .createDuration("30s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(dataformApi)
                .build());

        // Config without KMS key provided
        var config = new Config("config", ConfigArgs.builder()
            .region("us-central1")
            .project(project.projectId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(waitForDataformApi)
                .build());

    }
}

    resources:
  project:
    type: gcp:organizations:Project
    properties:
      name: project-1
      projectId: project-1
      orgId: '123456789'
      billingAccount: 000000-0000000-0000000-000000
      deletionPolicy: DELETE
  # Enable Dataform API
  dataformApi:
    type: gcp:projects:Service
    name: dataform_api
    properties:
      project: ${project.projectId}
      service: dataform.googleapis.com
      disableOnDestroy: false
  # Add a sleep to wait for IAM propagation after API enablement
  waitForDataformApi:
    type: time:Sleep
    name: wait_for_dataform_api
    properties:
      createDuration: 30s
    options:
      dependsOn:
        - ${dataformApi}
  # Config without KMS key provided
  config:
    type: gcp:dataform:Config
    properties:
      region: us-central1
      project: ${project.projectId}
    options:
      dependsOn:
        - ${waitForDataformApi}

    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,
           region: Optional[str] = None,
           default_kms_key_name: Optional[str] = None,
           project: 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:dataform: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 configResource = new Gcp.Dataform.Config("configResource", new()
{
    Region = "string",
    DefaultKmsKeyName = "string",
    Project = "string",
});

    example, err := dataform.NewConfig(ctx, "configResource", &dataform.ConfigArgs{
	Region:            pulumi.String("string"),
	DefaultKmsKeyName: pulumi.String("string"),
	Project:           pulumi.String("string"),
})

    var configResource = new com.pulumi.gcp.dataform.Config("configResource", com.pulumi.gcp.dataform.ConfigArgs.builder()
    .region("string")
    .defaultKmsKeyName("string")
    .project("string")
    .build());

    config_resource = gcp.dataform.Config("configResource",
    region="string",
    default_kms_key_name="string",
    project="string")

    const configResource = new gcp.dataform.Config("configResource", {
    region: "string",
    defaultKmsKeyName: "string",
    project: "string",
});

    type: gcp:dataform:Config
properties:
    defaultKmsKeyName: string
    project: string
    region: 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:

    Region string
    A reference to the region
    DefaultKmsKeyName string
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Region string
    A reference to the region
    DefaultKmsKeyName string
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region String
    A reference to the region
    defaultKmsKeyName String
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region string
    A reference to the region
    defaultKmsKeyName string
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region str
    A reference to the region
    default_kms_key_name str
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region String
    A reference to the region
    defaultKmsKeyName String
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    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,
        default_kms_key_name: Optional[str] = None,
        project: Optional[str] = None,
        region: 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:dataform: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:
    DefaultKmsKeyName string
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Region string
    A reference to the region
    DefaultKmsKeyName string
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Region string
    A reference to the region
    defaultKmsKeyName String
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region String
    A reference to the region
    defaultKmsKeyName string
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region string
    A reference to the region
    default_kms_key_name str
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region str
    A reference to the region
    defaultKmsKeyName String
    Optional. A reference to the customer-managed encryption key (CMEK) that will be used by default to encrypt user data.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    region String
    A reference to the region

    Import

    Config can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{region}}/config
    • {{project}}/{{region}}
    • {{region}}

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

    $ pulumi import gcp:dataform/config:Config default projects/{{project}}/locations/{{region}}/config
$ pulumi import gcp:dataform/config:Config default {{project}}/{{region}}
$ pulumi import gcp:dataform/config:Config default {{region}}

    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.15.0
    published on Thursday, Mar 12, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-gcp
      Try Pulumi Cloud free. Your team will thank you.