1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. biglake
  5. IcebergTable
Viewing docs for Google Cloud v9.18.0
published on Wednesday, Apr 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

gcp.biglake.IcebergTable

gcp logo
Viewing docs for Google Cloud v9.18.0
published on Wednesday, Apr 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-gcp

    IcebergTables are the primary objects in an IcebergCatalog.

    Example Usage

    Biglake Iceberg Table Basic

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

const bucket = new gcp.storage.Bucket("bucket", {
    name: "my-bucket-_15222",
    location: "us-central1",
    forceDestroy: true,
    uniformBucketLevelAccess: true,
});
const catalog = new gcp.biglake.IcebergCatalog("catalog", {
    name: bucket.name,
    catalogType: "CATALOG_TYPE_GCS_BUCKET",
});
const namespace = new gcp.biglake.IcebergNamespace("namespace", {
    catalog: catalog.name,
    namespaceId: "my_namespace__81126",
});
const myIcebergTable = new gcp.biglake.IcebergTable("my_iceberg_table", {
    catalog: catalog.name,
    namespace: namespace.namespaceId,
    name: "my_table__88717",
    location: pulumi.interpolate`gs://${bucket.name}/${namespace.namespaceId}/my_table__85794`,
    schema: {
        type: "struct",
        fields: [
            {
                id: 1,
                name: "id",
                type: "long",
                required: true,
                doc: "The ID of the record",
            },
            {
                id: 2,
                name: "name",
                type: "string",
                required: false,
            },
        ],
        identifierFieldIds: [1],
    },
    partitionSpec: {
        fields: [{
            name: "id_partition",
            sourceId: 1,
            transform: "identity",
        }],
    },
});

    import pulumi
import pulumi_gcp as gcp

bucket = gcp.storage.Bucket("bucket",
    name="my-bucket-_15222",
    location="us-central1",
    force_destroy=True,
    uniform_bucket_level_access=True)
catalog = gcp.biglake.IcebergCatalog("catalog",
    name=bucket.name,
    catalog_type="CATALOG_TYPE_GCS_BUCKET")
namespace = gcp.biglake.IcebergNamespace("namespace",
    catalog=catalog.name,
    namespace_id="my_namespace__81126")
my_iceberg_table = gcp.biglake.IcebergTable("my_iceberg_table",
    catalog=catalog.name,
    namespace=namespace.namespace_id,
    name="my_table__88717",
    location=pulumi.Output.all(
        name=bucket.name,
        namespace_id=namespace.namespace_id
).apply(lambda resolved_outputs: f"gs://{resolved_outputs['name']}/{resolved_outputs['namespace_id']}/my_table__85794")
,
    schema={
        "type": "struct",
        "fields": [
            {
                "id": 1,
                "name": "id",
                "type": "long",
                "required": True,
                "doc": "The ID of the record",
            },
            {
                "id": 2,
                "name": "name",
                "type": "string",
                "required": False,
            },
        ],
        "identifier_field_ids": [1],
    },
    partition_spec={
        "fields": [{
            "name": "id_partition",
            "source_id": 1,
            "transform": "identity",
        }],
    })

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/biglake"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my-bucket-_15222"),
			Location:                 pulumi.String("us-central1"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		catalog, err := biglake.NewIcebergCatalog(ctx, "catalog", &biglake.IcebergCatalogArgs{
			Name:        bucket.Name,
			CatalogType: pulumi.String("CATALOG_TYPE_GCS_BUCKET"),
		})
		if err != nil {
			return err
		}
		namespace, err := biglake.NewIcebergNamespace(ctx, "namespace", &biglake.IcebergNamespaceArgs{
			Catalog:     catalog.Name,
			NamespaceId: pulumi.String("my_namespace__81126"),
		})
		if err != nil {
			return err
		}
		_, err = biglake.NewIcebergTable(ctx, "my_iceberg_table", &biglake.IcebergTableArgs{
			Catalog:   catalog.Name,
			Namespace: namespace.NamespaceId,
			Name:      pulumi.String("my_table__88717"),
			Location: pulumi.All(bucket.Name, namespace.NamespaceId).ApplyT(func(_args []interface{}) (string, error) {
				name := _args[0].(string)
				namespaceId := _args[1].(string)
				return fmt.Sprintf("gs://%v/%v/my_table__85794", name, namespaceId), nil
			}).(pulumi.StringOutput),
			Schema: &biglake.IcebergTableSchemaArgs{
				Type: pulumi.String("struct"),
				Fields: biglake.IcebergTableSchemaFieldArray{
					&biglake.IcebergTableSchemaFieldArgs{
						Id:       pulumi.Int(1),
						Name:     pulumi.String("id"),
						Type:     pulumi.String("long"),
						Required: pulumi.Bool(true),
						Doc:      pulumi.String("The ID of the record"),
					},
					&biglake.IcebergTableSchemaFieldArgs{
						Id:       pulumi.Int(2),
						Name:     pulumi.String("name"),
						Type:     pulumi.String("string"),
						Required: pulumi.Bool(false),
					},
				},
				IdentifierFieldIds: pulumi.IntArray{
					pulumi.Int(1),
				},
			},
			PartitionSpec: &biglake.IcebergTablePartitionSpecArgs{
				Fields: biglake.IcebergTablePartitionSpecFieldArray{
					&biglake.IcebergTablePartitionSpecFieldArgs{
						Name:      pulumi.String("id_partition"),
						SourceId:  pulumi.Int(1),
						Transform: pulumi.String("identity"),
					},
				},
			},
		})
		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 bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Name = "my-bucket-_15222",
        Location = "us-central1",
        ForceDestroy = true,
        UniformBucketLevelAccess = true,
    });

    var catalog = new Gcp.BigLake.IcebergCatalog("catalog", new()
    {
        Name = bucket.Name,
        CatalogType = "CATALOG_TYPE_GCS_BUCKET",
    });

    var @namespace = new Gcp.BigLake.IcebergNamespace("namespace", new()
    {
        Catalog = catalog.Name,
        NamespaceId = "my_namespace__81126",
    });

    var myIcebergTable = new Gcp.BigLake.IcebergTable("my_iceberg_table", new()
    {
        Catalog = catalog.Name,
        Namespace = @namespace.NamespaceId,
        Name = "my_table__88717",
        Location = Output.Tuple(bucket.Name, @namespace.NamespaceId).Apply(values =>
        {
            var name = values.Item1;
            var namespaceId = values.Item2;
            return $"gs://{name}/{namespaceId}/my_table__85794";
        }),
        Schema = new Gcp.BigLake.Inputs.IcebergTableSchemaArgs
        {
            Type = "struct",
            Fields = new[]
            {
                new Gcp.BigLake.Inputs.IcebergTableSchemaFieldArgs
                {
                    Id = 1,
                    Name = "id",
                    Type = "long",
                    Required = true,
                    Doc = "The ID of the record",
                },
                new Gcp.BigLake.Inputs.IcebergTableSchemaFieldArgs
                {
                    Id = 2,
                    Name = "name",
                    Type = "string",
                    Required = false,
                },
            },
            IdentifierFieldIds = new[]
            {
                1,
            },
        },
        PartitionSpec = new Gcp.BigLake.Inputs.IcebergTablePartitionSpecArgs
        {
            Fields = new[]
            {
                new Gcp.BigLake.Inputs.IcebergTablePartitionSpecFieldArgs
                {
                    Name = "id_partition",
                    SourceId = 1,
                    Transform = "identity",
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.biglake.IcebergCatalog;
import com.pulumi.gcp.biglake.IcebergCatalogArgs;
import com.pulumi.gcp.biglake.IcebergNamespace;
import com.pulumi.gcp.biglake.IcebergNamespaceArgs;
import com.pulumi.gcp.biglake.IcebergTable;
import com.pulumi.gcp.biglake.IcebergTableArgs;
import com.pulumi.gcp.biglake.inputs.IcebergTableSchemaArgs;
import com.pulumi.gcp.biglake.inputs.IcebergTablePartitionSpecArgs;
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 bucket = new Bucket("bucket", BucketArgs.builder()
            .name("my-bucket-_15222")
            .location("us-central1")
            .forceDestroy(true)
            .uniformBucketLevelAccess(true)
            .build());

        var catalog = new IcebergCatalog("catalog", IcebergCatalogArgs.builder()
            .name(bucket.name())
            .catalogType("CATALOG_TYPE_GCS_BUCKET")
            .build());

        var namespace = new IcebergNamespace("namespace", IcebergNamespaceArgs.builder()
            .catalog(catalog.name())
            .namespaceId("my_namespace__81126")
            .build());

        var myIcebergTable = new IcebergTable("myIcebergTable", IcebergTableArgs.builder()
            .catalog(catalog.name())
            .namespace(namespace.namespaceId())
            .name("my_table__88717")
            .location(Output.tuple(bucket.name(), namespace.namespaceId()).applyValue(values -> {
                var name = values.t1;
                var namespaceId = values.t2;
                return String.format("gs://%s/%s/my_table__85794", name,namespaceId);
            }))
            .schema(IcebergTableSchemaArgs.builder()
                .type("struct")
                .fields(                
                    IcebergTableSchemaFieldArgs.builder()
                        .id(1)
                        .name("id")
                        .type("long")
                        .required(true)
                        .doc("The ID of the record")
                        .build(),
                    IcebergTableSchemaFieldArgs.builder()
                        .id(2)
                        .name("name")
                        .type("string")
                        .required(false)
                        .build())
                .identifierFieldIds(1)
                .build())
            .partitionSpec(IcebergTablePartitionSpecArgs.builder()
                .fields(IcebergTablePartitionSpecFieldArgs.builder()
                    .name("id_partition")
                    .sourceId(1)
                    .transform("identity")
                    .build())
                .build())
            .build());

    }
}

    resources:
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: my-bucket-_15222
      location: us-central1
      forceDestroy: true
      uniformBucketLevelAccess: true
  catalog:
    type: gcp:biglake:IcebergCatalog
    properties:
      name: ${bucket.name}
      catalogType: CATALOG_TYPE_GCS_BUCKET
  namespace:
    type: gcp:biglake:IcebergNamespace
    properties:
      catalog: ${catalog.name}
      namespaceId: my_namespace__81126
  myIcebergTable:
    type: gcp:biglake:IcebergTable
    name: my_iceberg_table
    properties:
      catalog: ${catalog.name}
      namespace: ${namespace.namespaceId}
      name: my_table__88717
      location: gs://${bucket.name}/${namespace.namespaceId}/my_table__85794
      schema:
        type: struct
        fields:
          - id: 1
            name: id
            type: long
            required: true
            doc: The ID of the record
          - id: 2
            name: name
            type: string
            required: false
        identifierFieldIds:
          - 1
      partitionSpec:
        fields:
          - name: id_partition
            sourceId: 1
            transform: identity

    Biglake Iceberg Table Update

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

const bucket = new gcp.storage.Bucket("bucket", {
    name: "my-bucket-_21197",
    location: "us-central1",
    forceDestroy: true,
    uniformBucketLevelAccess: true,
});
const catalog = new gcp.biglake.IcebergCatalog("catalog", {
    name: bucket.name,
    catalogType: "CATALOG_TYPE_GCS_BUCKET",
});
const namespace = new gcp.biglake.IcebergNamespace("namespace", {
    catalog: catalog.name,
    namespaceId: "my_namespace__52865",
});
const myIcebergTable = new gcp.biglake.IcebergTable("my_iceberg_table", {
    catalog: catalog.name,
    namespace: namespace.namespaceId,
    name: "my_table__85840",
    schema: {
        type: "struct",
        fields: [{
            id: 1,
            name: "id",
            type: "long",
            required: true,
        }],
    },
    properties: {
        key: "value",
    },
});

    import pulumi
import pulumi_gcp as gcp

bucket = gcp.storage.Bucket("bucket",
    name="my-bucket-_21197",
    location="us-central1",
    force_destroy=True,
    uniform_bucket_level_access=True)
catalog = gcp.biglake.IcebergCatalog("catalog",
    name=bucket.name,
    catalog_type="CATALOG_TYPE_GCS_BUCKET")
namespace = gcp.biglake.IcebergNamespace("namespace",
    catalog=catalog.name,
    namespace_id="my_namespace__52865")
my_iceberg_table = gcp.biglake.IcebergTable("my_iceberg_table",
    catalog=catalog.name,
    namespace=namespace.namespace_id,
    name="my_table__85840",
    schema={
        "type": "struct",
        "fields": [{
            "id": 1,
            "name": "id",
            "type": "long",
            "required": True,
        }],
    },
    properties={
        "key": "value",
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my-bucket-_21197"),
			Location:                 pulumi.String("us-central1"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		catalog, err := biglake.NewIcebergCatalog(ctx, "catalog", &biglake.IcebergCatalogArgs{
			Name:        bucket.Name,
			CatalogType: pulumi.String("CATALOG_TYPE_GCS_BUCKET"),
		})
		if err != nil {
			return err
		}
		namespace, err := biglake.NewIcebergNamespace(ctx, "namespace", &biglake.IcebergNamespaceArgs{
			Catalog:     catalog.Name,
			NamespaceId: pulumi.String("my_namespace__52865"),
		})
		if err != nil {
			return err
		}
		_, err = biglake.NewIcebergTable(ctx, "my_iceberg_table", &biglake.IcebergTableArgs{
			Catalog:   catalog.Name,
			Namespace: namespace.NamespaceId,
			Name:      pulumi.String("my_table__85840"),
			Schema: &biglake.IcebergTableSchemaArgs{
				Type: pulumi.String("struct"),
				Fields: biglake.IcebergTableSchemaFieldArray{
					&biglake.IcebergTableSchemaFieldArgs{
						Id:       pulumi.Int(1),
						Name:     pulumi.String("id"),
						Type:     pulumi.String("long"),
						Required: pulumi.Bool(true),
					},
				},
			},
			Properties: pulumi.StringMap{
				"key": pulumi.String("value"),
			},
		})
		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 bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Name = "my-bucket-_21197",
        Location = "us-central1",
        ForceDestroy = true,
        UniformBucketLevelAccess = true,
    });

    var catalog = new Gcp.BigLake.IcebergCatalog("catalog", new()
    {
        Name = bucket.Name,
        CatalogType = "CATALOG_TYPE_GCS_BUCKET",
    });

    var @namespace = new Gcp.BigLake.IcebergNamespace("namespace", new()
    {
        Catalog = catalog.Name,
        NamespaceId = "my_namespace__52865",
    });

    var myIcebergTable = new Gcp.BigLake.IcebergTable("my_iceberg_table", new()
    {
        Catalog = catalog.Name,
        Namespace = @namespace.NamespaceId,
        Name = "my_table__85840",
        Schema = new Gcp.BigLake.Inputs.IcebergTableSchemaArgs
        {
            Type = "struct",
            Fields = new[]
            {
                new Gcp.BigLake.Inputs.IcebergTableSchemaFieldArgs
                {
                    Id = 1,
                    Name = "id",
                    Type = "long",
                    Required = true,
                },
            },
        },
        Properties = 
        {
            { "key", "value" },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.biglake.IcebergCatalog;
import com.pulumi.gcp.biglake.IcebergCatalogArgs;
import com.pulumi.gcp.biglake.IcebergNamespace;
import com.pulumi.gcp.biglake.IcebergNamespaceArgs;
import com.pulumi.gcp.biglake.IcebergTable;
import com.pulumi.gcp.biglake.IcebergTableArgs;
import com.pulumi.gcp.biglake.inputs.IcebergTableSchemaArgs;
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 bucket = new Bucket("bucket", BucketArgs.builder()
            .name("my-bucket-_21197")
            .location("us-central1")
            .forceDestroy(true)
            .uniformBucketLevelAccess(true)
            .build());

        var catalog = new IcebergCatalog("catalog", IcebergCatalogArgs.builder()
            .name(bucket.name())
            .catalogType("CATALOG_TYPE_GCS_BUCKET")
            .build());

        var namespace = new IcebergNamespace("namespace", IcebergNamespaceArgs.builder()
            .catalog(catalog.name())
            .namespaceId("my_namespace__52865")
            .build());

        var myIcebergTable = new IcebergTable("myIcebergTable", IcebergTableArgs.builder()
            .catalog(catalog.name())
            .namespace(namespace.namespaceId())
            .name("my_table__85840")
            .schema(IcebergTableSchemaArgs.builder()
                .type("struct")
                .fields(IcebergTableSchemaFieldArgs.builder()
                    .id(1)
                    .name("id")
                    .type("long")
                    .required(true)
                    .build())
                .build())
            .properties(Map.of("key", "value"))
            .build());

    }
}

    resources:
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: my-bucket-_21197
      location: us-central1
      forceDestroy: true
      uniformBucketLevelAccess: true
  catalog:
    type: gcp:biglake:IcebergCatalog
    properties:
      name: ${bucket.name}
      catalogType: CATALOG_TYPE_GCS_BUCKET
  namespace:
    type: gcp:biglake:IcebergNamespace
    properties:
      catalog: ${catalog.name}
      namespaceId: my_namespace__52865
  myIcebergTable:
    type: gcp:biglake:IcebergTable
    name: my_iceberg_table
    properties:
      catalog: ${catalog.name}
      namespace: ${namespace.namespaceId}
      name: my_table__85840
      schema:
        type: struct
        fields:
          - id: 1
            name: id
            type: long
            required: true
      properties:
        key: value

    Create IcebergTable Resource

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

    Constructor syntax

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

@overload
def IcebergTable(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 catalog: Optional[str] = None,
                 namespace: Optional[str] = None,
                 schema: Optional[IcebergTableSchemaArgs] = None,
                 location: Optional[str] = None,
                 name: Optional[str] = None,
                 partition_spec: Optional[IcebergTablePartitionSpecArgs] = None,
                 project: Optional[str] = None,
                 properties: Optional[Mapping[str, str]] = None)
    func NewIcebergTable(ctx *Context, name string, args IcebergTableArgs, opts ...ResourceOption) (*IcebergTable, error)
    public IcebergTable(string name, IcebergTableArgs args, CustomResourceOptions? opts = null)
    public IcebergTable(String name, IcebergTableArgs args)
public IcebergTable(String name, IcebergTableArgs args, CustomResourceOptions options)

    type: gcp:biglake:IcebergTable
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 IcebergTableArgs
    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 IcebergTableArgs
    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 IcebergTableArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args IcebergTableArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args IcebergTableArgs
    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 icebergTableResource = new Gcp.BigLake.IcebergTable("icebergTableResource", new()
{
    Catalog = "string",
    Namespace = "string",
    Schema = new Gcp.BigLake.Inputs.IcebergTableSchemaArgs
    {
        Fields = new[]
        {
            new Gcp.BigLake.Inputs.IcebergTableSchemaFieldArgs
            {
                Id = 0,
                Name = "string",
                Required = false,
                Type = "string",
                Doc = "string",
            },
        },
        IdentifierFieldIds = new[]
        {
            0,
        },
        SchemaId = 0,
        Type = "string",
    },
    Location = "string",
    Name = "string",
    PartitionSpec = new Gcp.BigLake.Inputs.IcebergTablePartitionSpecArgs
    {
        Fields = new[]
        {
            new Gcp.BigLake.Inputs.IcebergTablePartitionSpecFieldArgs
            {
                Name = "string",
                SourceId = 0,
                Transform = "string",
                FieldId = 0,
            },
        },
        SpecId = 0,
    },
    Project = "string",
    Properties = 
    {
        { "string", "string" },
    },
});

    example, err := biglake.NewIcebergTable(ctx, "icebergTableResource", &biglake.IcebergTableArgs{
	Catalog:   pulumi.String("string"),
	Namespace: pulumi.String("string"),
	Schema: &biglake.IcebergTableSchemaArgs{
		Fields: biglake.IcebergTableSchemaFieldArray{
			&biglake.IcebergTableSchemaFieldArgs{
				Id:       pulumi.Int(0),
				Name:     pulumi.String("string"),
				Required: pulumi.Bool(false),
				Type:     pulumi.String("string"),
				Doc:      pulumi.String("string"),
			},
		},
		IdentifierFieldIds: pulumi.IntArray{
			pulumi.Int(0),
		},
		SchemaId: pulumi.Int(0),
		Type:     pulumi.String("string"),
	},
	Location: pulumi.String("string"),
	Name:     pulumi.String("string"),
	PartitionSpec: &biglake.IcebergTablePartitionSpecArgs{
		Fields: biglake.IcebergTablePartitionSpecFieldArray{
			&biglake.IcebergTablePartitionSpecFieldArgs{
				Name:      pulumi.String("string"),
				SourceId:  pulumi.Int(0),
				Transform: pulumi.String("string"),
				FieldId:   pulumi.Int(0),
			},
		},
		SpecId: pulumi.Int(0),
	},
	Project: pulumi.String("string"),
	Properties: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
})

    var icebergTableResource = new IcebergTable("icebergTableResource", IcebergTableArgs.builder()
    .catalog("string")
    .namespace("string")
    .schema(IcebergTableSchemaArgs.builder()
        .fields(IcebergTableSchemaFieldArgs.builder()
            .id(0)
            .name("string")
            .required(false)
            .type("string")
            .doc("string")
            .build())
        .identifierFieldIds(0)
        .schemaId(0)
        .type("string")
        .build())
    .location("string")
    .name("string")
    .partitionSpec(IcebergTablePartitionSpecArgs.builder()
        .fields(IcebergTablePartitionSpecFieldArgs.builder()
            .name("string")
            .sourceId(0)
            .transform("string")
            .fieldId(0)
            .build())
        .specId(0)
        .build())
    .project("string")
    .properties(Map.of("string", "string"))
    .build());

    iceberg_table_resource = gcp.biglake.IcebergTable("icebergTableResource",
    catalog="string",
    namespace="string",
    schema={
        "fields": [{
            "id": 0,
            "name": "string",
            "required": False,
            "type": "string",
            "doc": "string",
        }],
        "identifier_field_ids": [0],
        "schema_id": 0,
        "type": "string",
    },
    location="string",
    name="string",
    partition_spec={
        "fields": [{
            "name": "string",
            "source_id": 0,
            "transform": "string",
            "field_id": 0,
        }],
        "spec_id": 0,
    },
    project="string",
    properties={
        "string": "string",
    })

    const icebergTableResource = new gcp.biglake.IcebergTable("icebergTableResource", {
    catalog: "string",
    namespace: "string",
    schema: {
        fields: [{
            id: 0,
            name: "string",
            required: false,
            type: "string",
            doc: "string",
        }],
        identifierFieldIds: [0],
        schemaId: 0,
        type: "string",
    },
    location: "string",
    name: "string",
    partitionSpec: {
        fields: [{
            name: "string",
            sourceId: 0,
            transform: "string",
            fieldId: 0,
        }],
        specId: 0,
    },
    project: "string",
    properties: {
        string: "string",
    },
});

    type: gcp:biglake:IcebergTable
properties:
    catalog: string
    location: string
    name: string
    namespace: string
    partitionSpec:
        fields:
            - fieldId: 0
              name: string
              sourceId: 0
              transform: string
        specId: 0
    project: string
    properties:
        string: string
    schema:
        fields:
            - doc: string
              id: 0
              name: string
              required: false
              type: string
        identifierFieldIds:
            - 0
        schemaId: 0
        type: string

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

    Catalog string
    The name of the IcebergCatalog.
    Namespace string
    The parent namespace of the table.
    Schema IcebergTableSchema
    The schema of the table. Structure is documented below.
    Location string
    The location of the table.
    Name string
    The name of the table.
    PartitionSpec IcebergTablePartitionSpec
    The partition spec of the table. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Properties Dictionary<string, string>
    User-defined properties for the table.
    Catalog string
    The name of the IcebergCatalog.
    Namespace string
    The parent namespace of the table.
    Schema IcebergTableSchemaArgs
    The schema of the table. Structure is documented below.
    Location string
    The location of the table.
    Name string
    The name of the table.
    PartitionSpec IcebergTablePartitionSpecArgs
    The partition spec of the table. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Properties map[string]string
    User-defined properties for the table.
    catalog String
    The name of the IcebergCatalog.
    namespace String
    The parent namespace of the table.
    schema IcebergTableSchema
    The schema of the table. Structure is documented below.
    location String
    The location of the table.
    name String
    The name of the table.
    partitionSpec IcebergTablePartitionSpec
    The partition spec of the table. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties Map<String,String>
    User-defined properties for the table.
    catalog string
    The name of the IcebergCatalog.
    namespace string
    The parent namespace of the table.
    schema IcebergTableSchema
    The schema of the table. Structure is documented below.
    location string
    The location of the table.
    name string
    The name of the table.
    partitionSpec IcebergTablePartitionSpec
    The partition spec of the table. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties {[key: string]: string}
    User-defined properties for the table.
    catalog str
    The name of the IcebergCatalog.
    namespace str
    The parent namespace of the table.
    schema IcebergTableSchemaArgs
    The schema of the table. Structure is documented below.
    location str
    The location of the table.
    name str
    The name of the table.
    partition_spec IcebergTablePartitionSpecArgs
    The partition spec of the table. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties Mapping[str, str]
    User-defined properties for the table.
    catalog String
    The name of the IcebergCatalog.
    namespace String
    The parent namespace of the table.
    schema Property Map
    The schema of the table. Structure is documented below.
    location String
    The location of the table.
    name String
    The name of the table.
    partitionSpec Property Map
    The partition spec of the table. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties Map<String>
    User-defined properties for the table.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the IcebergTable 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 IcebergTable Resource

    Get an existing IcebergTable 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?: IcebergTableState, opts?: CustomResourceOptions): IcebergTable
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        catalog: Optional[str] = None,
        location: Optional[str] = None,
        name: Optional[str] = None,
        namespace: Optional[str] = None,
        partition_spec: Optional[IcebergTablePartitionSpecArgs] = None,
        project: Optional[str] = None,
        properties: Optional[Mapping[str, str]] = None,
        schema: Optional[IcebergTableSchemaArgs] = None) -> IcebergTable
    func GetIcebergTable(ctx *Context, name string, id IDInput, state *IcebergTableState, opts ...ResourceOption) (*IcebergTable, error)
    public static IcebergTable Get(string name, Input<string> id, IcebergTableState? state, CustomResourceOptions? opts = null)
    public static IcebergTable get(String name, Output<String> id, IcebergTableState state, CustomResourceOptions options)
    resources:  _:    type: gcp:biglake:IcebergTable    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:
    Catalog string
    The name of the IcebergCatalog.
    Location string
    The location of the table.
    Name string
    The name of the table.
    Namespace string
    The parent namespace of the table.
    PartitionSpec IcebergTablePartitionSpec
    The partition spec of the table. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Properties Dictionary<string, string>
    User-defined properties for the table.
    Schema IcebergTableSchema
    The schema of the table. Structure is documented below.
    Catalog string
    The name of the IcebergCatalog.
    Location string
    The location of the table.
    Name string
    The name of the table.
    Namespace string
    The parent namespace of the table.
    PartitionSpec IcebergTablePartitionSpecArgs
    The partition spec of the table. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    Properties map[string]string
    User-defined properties for the table.
    Schema IcebergTableSchemaArgs
    The schema of the table. Structure is documented below.
    catalog String
    The name of the IcebergCatalog.
    location String
    The location of the table.
    name String
    The name of the table.
    namespace String
    The parent namespace of the table.
    partitionSpec IcebergTablePartitionSpec
    The partition spec of the table. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties Map<String,String>
    User-defined properties for the table.
    schema IcebergTableSchema
    The schema of the table. Structure is documented below.
    catalog string
    The name of the IcebergCatalog.
    location string
    The location of the table.
    name string
    The name of the table.
    namespace string
    The parent namespace of the table.
    partitionSpec IcebergTablePartitionSpec
    The partition spec of the table. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties {[key: string]: string}
    User-defined properties for the table.
    schema IcebergTableSchema
    The schema of the table. Structure is documented below.
    catalog str
    The name of the IcebergCatalog.
    location str
    The location of the table.
    name str
    The name of the table.
    namespace str
    The parent namespace of the table.
    partition_spec IcebergTablePartitionSpecArgs
    The partition spec of the table. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties Mapping[str, str]
    User-defined properties for the table.
    schema IcebergTableSchemaArgs
    The schema of the table. Structure is documented below.
    catalog String
    The name of the IcebergCatalog.
    location String
    The location of the table.
    name String
    The name of the table.
    namespace String
    The parent namespace of the table.
    partitionSpec Property Map
    The partition spec of the table. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    properties Map<String>
    User-defined properties for the table.
    schema Property Map
    The schema of the table. Structure is documented below.

    Supporting Types

    IcebergTablePartitionSpec, IcebergTablePartitionSpecArgs

    Fields List<IcebergTablePartitionSpecField>
    Structure is documented below.
    SpecId int
    (Output) The unique identifier of the partition spec.
    Fields []IcebergTablePartitionSpecField
    Structure is documented below.
    SpecId int
    (Output) The unique identifier of the partition spec.
    fields List<IcebergTablePartitionSpecField>
    Structure is documented below.
    specId Integer
    (Output) The unique identifier of the partition spec.
    fields IcebergTablePartitionSpecField[]
    Structure is documented below.
    specId number
    (Output) The unique identifier of the partition spec.
    fields Sequence[IcebergTablePartitionSpecField]
    Structure is documented below.
    spec_id int
    (Output) The unique identifier of the partition spec.
    fields List<Property Map>
    Structure is documented below.
    specId Number
    (Output) The unique identifier of the partition spec.

    IcebergTablePartitionSpecField, IcebergTablePartitionSpecFieldArgs

    Name string
    The name of the partition field.
    SourceId int
    The source field ID for the partition field.
    Transform string
    The transform to apply to the source field.
    FieldId int
    (Output) The unique identifier of the partition field.
    Name string
    The name of the partition field.
    SourceId int
    The source field ID for the partition field.
    Transform string
    The transform to apply to the source field.
    FieldId int
    (Output) The unique identifier of the partition field.
    name String
    The name of the partition field.
    sourceId Integer
    The source field ID for the partition field.
    transform String
    The transform to apply to the source field.
    fieldId Integer
    (Output) The unique identifier of the partition field.
    name string
    The name of the partition field.
    sourceId number
    The source field ID for the partition field.
    transform string
    The transform to apply to the source field.
    fieldId number
    (Output) The unique identifier of the partition field.
    name str
    The name of the partition field.
    source_id int
    The source field ID for the partition field.
    transform str
    The transform to apply to the source field.
    field_id int
    (Output) The unique identifier of the partition field.
    name String
    The name of the partition field.
    sourceId Number
    The source field ID for the partition field.
    transform String
    The transform to apply to the source field.
    fieldId Number
    (Output) The unique identifier of the partition field.

    IcebergTableSchema, IcebergTableSchemaArgs

    Fields List<IcebergTableSchemaField>
    Structure is documented below.
    IdentifierFieldIds List<int>
    The field IDs that make up the identifier for the table.
    SchemaId int
    (Output) The unique identifier of the schema.
    Type string
    The type of the schema.
    Fields []IcebergTableSchemaField
    Structure is documented below.
    IdentifierFieldIds []int
    The field IDs that make up the identifier for the table.
    SchemaId int
    (Output) The unique identifier of the schema.
    Type string
    The type of the schema.
    fields List<IcebergTableSchemaField>
    Structure is documented below.
    identifierFieldIds List<Integer>
    The field IDs that make up the identifier for the table.
    schemaId Integer
    (Output) The unique identifier of the schema.
    type String
    The type of the schema.
    fields IcebergTableSchemaField[]
    Structure is documented below.
    identifierFieldIds number[]
    The field IDs that make up the identifier for the table.
    schemaId number
    (Output) The unique identifier of the schema.
    type string
    The type of the schema.
    fields Sequence[IcebergTableSchemaField]
    Structure is documented below.
    identifier_field_ids Sequence[int]
    The field IDs that make up the identifier for the table.
    schema_id int
    (Output) The unique identifier of the schema.
    type str
    The type of the schema.
    fields List<Property Map>
    Structure is documented below.
    identifierFieldIds List<Number>
    The field IDs that make up the identifier for the table.
    schemaId Number
    (Output) The unique identifier of the schema.
    type String
    The type of the schema.

    IcebergTableSchemaField, IcebergTableSchemaFieldArgs

    Id int
    The unique identifier of the field.
    Name string
    The name of the partition field.
    Required bool
    Whether the field is required.
    Type string
    The type of the field.
    Doc string
    A description of the field.
    Id int
    The unique identifier of the field.
    Name string
    The name of the partition field.
    Required bool
    Whether the field is required.
    Type string
    The type of the field.
    Doc string
    A description of the field.
    id Integer
    The unique identifier of the field.
    name String
    The name of the partition field.
    required Boolean
    Whether the field is required.
    type String
    The type of the field.
    doc String
    A description of the field.
    id number
    The unique identifier of the field.
    name string
    The name of the partition field.
    required boolean
    Whether the field is required.
    type string
    The type of the field.
    doc string
    A description of the field.
    id int
    The unique identifier of the field.
    name str
    The name of the partition field.
    required bool
    Whether the field is required.
    type str
    The type of the field.
    doc str
    A description of the field.
    id Number
    The unique identifier of the field.
    name String
    The name of the partition field.
    required Boolean
    Whether the field is required.
    type String
    The type of the field.
    doc String
    A description of the field.

    Import

    IcebergTable can be imported using any of these accepted formats:

    • projects/{{project}}/catalogs/{{catalog}}/namespaces/{{namespace}}/tables/{{name}}
    • {{project}}/{{catalog}}/{{namespace}}/{{name}}
    • {{catalog}}/{{namespace}}/{{name}}

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

    $ pulumi import gcp:biglake/icebergTable:IcebergTable default projects/{{project}}/catalogs/{{catalog}}/namespaces/{{namespace}}/tables/{{name}}
$ pulumi import gcp:biglake/icebergTable:IcebergTable default {{project}}/{{catalog}}/{{namespace}}/{{name}}
$ pulumi import gcp:biglake/icebergTable:IcebergTable default {{catalog}}/{{namespace}}/{{name}}

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