using Pulumi;
using Gcp = Pulumi.Gcp;

class MyStack : Stack
{
    public MyStack()
    {
        var instance = new Gcp.BigTable.Instance("instance", new Gcp.BigTable.InstanceArgs
        {
            Clusters = 
            {
                new Gcp.BigTable.Inputs.InstanceClusterArgs
                {
                    ClusterId = "tf-instance-cluster",
                    NumNodes = 3,
                    StorageType = "HDD",
                },
            },
        });
        var table = new Gcp.BigTable.Table("table", new Gcp.BigTable.TableArgs
        {
            InstanceName = instance.Name,
            ColumnFamilies = 
            {
                new Gcp.BigTable.Inputs.TableColumnFamilyArgs
                {
                    Family = "name",
                },
            },
        });
        var policy = new Gcp.BigTable.GCPolicy("policy", new Gcp.BigTable.GCPolicyArgs
        {
            InstanceName = instance.Name,
            Table = table.Name,
            ColumnFamily = "name",
            MaxAge = new Gcp.BigTable.Inputs.GCPolicyMaxAgeArgs
            {
                Duration = "168h",
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/bigtable"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance, err := bigtable.NewInstance(ctx, "instance", &bigtable.InstanceArgs{
			Clusters: bigtable.InstanceClusterArray{
				&bigtable.InstanceClusterArgs{
					ClusterId:   pulumi.String("tf-instance-cluster"),
					NumNodes:    pulumi.Int(3),
					StorageType: pulumi.String("HDD"),
				},
			},
		})
		if err != nil {
			return err
		}
		table, err := bigtable.NewTable(ctx, "table", &bigtable.TableArgs{
			InstanceName: instance.Name,
			ColumnFamilies: bigtable.TableColumnFamilyArray{
				&bigtable.TableColumnFamilyArgs{
					Family: pulumi.String("name"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = bigtable.NewGCPolicy(ctx, "policy", &bigtable.GCPolicyArgs{
			InstanceName: instance.Name,
			Table:        table.Name,
			ColumnFamily: pulumi.String("name"),
			MaxAge: &bigtable.GCPolicyMaxAgeArgs{
				Duration: pulumi.String("168h"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import java.util.*;
import java.io.*;
import java.nio.*;
import com.pulumi.*;

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

    public static void stack(Context ctx) {
        var instance = new Instance("instance", InstanceArgs.builder()        
            .clusters(InstanceCluster.builder()
                .clusterId("tf-instance-cluster")
                .numNodes(3)
                .storageType("HDD")
                .build())
            .build());

        var table = new Table("table", TableArgs.builder()        
            .instanceName(instance.getName())
            .columnFamilies(TableColumnFamily.builder()
                .family("name")
                .build())
            .build());

        var policy = new GCPolicy("policy", GCPolicyArgs.builder()        
            .instanceName(instance.getName())
            .table(table.getName())
            .columnFamily("name")
            .maxAge(GCPolicyMaxAge.builder()
                .duration("168h")
                .build())
            .build());

        }
}

import pulumi
import pulumi_gcp as gcp

instance = gcp.bigtable.Instance("instance", clusters=[gcp.bigtable.InstanceClusterArgs(
    cluster_id="tf-instance-cluster",
    num_nodes=3,
    storage_type="HDD",
)])
table = gcp.bigtable.Table("table",
    instance_name=instance.name,
    column_families=[gcp.bigtable.TableColumnFamilyArgs(
        family="name",
    )])
policy = gcp.bigtable.GCPolicy("policy",
    instance_name=instance.name,
    table=table.name,
    column_family="name",
    max_age=gcp.bigtable.GCPolicyMaxAgeArgs(
        duration="168h",
    ))

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

const instance = new gcp.bigtable.Instance("instance", {clusters: [{
    clusterId: "tf-instance-cluster",
    numNodes: 3,
    storageType: "HDD",
}]});
const table = new gcp.bigtable.Table("table", {
    instanceName: instance.name,
    columnFamilies: [{
        family: "name",
    }],
});
const policy = new gcp.bigtable.GCPolicy("policy", {
    instanceName: instance.name,
    table: table.name,
    columnFamily: "name",
    maxAge: {
        duration: "168h",
    },
});

resources:
  instance:
    type: gcp:bigtable:Instance
    properties:
      clusters:
        - clusterId: tf-instance-cluster
          numNodes: 3
          storageType: HDD
  table:
    type: gcp:bigtable:Table
    properties:
      instanceName: ${instance.name}
      columnFamilies:
        - family: name
  policy:
    type: gcp:bigtable:GCPolicy
    properties:
      instanceName: ${instance.name}
      table: ${table.name}
      columnFamily: name
      maxAge:
        duration: 168h