MetastoreService class

A managed metastore service that serves metadata queries.

To get more information about Service, see:

Example Usage

Dataproc Metastore Service Basic

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

const _default = new gcp.dataproc.MetastoreService("default", {
    serviceId: "metastore-srv",
    location: "us-central1",
    port: 9080,
    tier: "DEVELOPER",
    maintenanceWindow: {
        hourOfDay: 2,
        dayOfWeek: "SUNDAY",
    },
    hiveMetastoreConfig: {
        version: "2.3.6",
    },
    labels: {
        env: "test",
    },
});

import pulumi
import pulumi_gcp as gcp

default = gcp.dataproc.MetastoreService("default",
    service_id="metastore-srv",
    location="us-central1",
    port=9080,
    tier="DEVELOPER",
    maintenance_window={
        "hour_of_day": 2,
        "day_of_week": "SUNDAY",
    },
    hive_metastore_config={
        "version": "2.3.6",
    },
    labels={
        "env": "test",
    })

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

return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.Dataproc.MetastoreService("default", new()
    {
        ServiceId = "metastore-srv",
        Location = "us-central1",
        Port = 9080,
        Tier = "DEVELOPER",
        MaintenanceWindow = new Gcp.Dataproc.Inputs.MetastoreServiceMaintenanceWindowArgs
        {
            HourOfDay = 2,
            DayOfWeek = "SUNDAY",
        },
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "2.3.6",
        },
        Labels =
        {
            { "env", "test" },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "default", &dataproc.MetastoreServiceArgs{
			ServiceId: pulumi.String("metastore-srv"),
			Location:  pulumi.String("us-central1"),
			Port:      pulumi.Int(9080),
			Tier:      pulumi.String("DEVELOPER"),
			MaintenanceWindow: &dataproc.MetastoreServiceMaintenanceWindowArgs{
				HourOfDay: pulumi.Int(2),
				DayOfWeek: pulumi.String("SUNDAY"),
			},
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("2.3.6"),
			},
			Labels: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "default" {
  service_id = "metastore-srv"
  location   = "us-central1"
  port       = 9080
  tier       = "DEVELOPER"
  maintenance_window = {
    hour_of_day = 2
    day_of_week = "SUNDAY"
  }
  hive_metastore_config = {
    version = "2.3.6"
  }
  labels = {
    "env" = "test"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceMaintenanceWindowArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var default_ = new MetastoreService("default", MetastoreServiceArgs.builder()
            .serviceId("metastore-srv")
            .location("us-central1")
            .port(9080)
            .tier("DEVELOPER")
            .maintenanceWindow(MetastoreServiceMaintenanceWindowArgs.builder()
                .hourOfDay(2)
                .dayOfWeek("SUNDAY")
                .build())
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("2.3.6")
                .build())
            .labels(Map.of("env", "test"))
            .build());

    }
}

resources:
  default:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: metastore-srv
      location: us-central1
      port: 9080
      tier: DEVELOPER
      maintenanceWindow:
        hourOfDay: 2
        dayOfWeek: SUNDAY
      hiveMetastoreConfig:
        version: 2.3.6
      labels:
        env: test

Dataproc Metastore Service Deletion Protection

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

const _default = new gcp.dataproc.MetastoreService("default", {
    serviceId: "metastore-srv",
    location: "us-central1",
    port: 9080,
    tier: "DEVELOPER",
    deletionProtection: true,
    maintenanceWindow: {
        hourOfDay: 2,
        dayOfWeek: "SUNDAY",
    },
    hiveMetastoreConfig: {
        version: "2.3.6",
    },
    labels: {
        env: "test",
    },
});

import pulumi
import pulumi_gcp as gcp

default = gcp.dataproc.MetastoreService("default",
    service_id="metastore-srv",
    location="us-central1",
    port=9080,
    tier="DEVELOPER",
    deletion_protection=True,
    maintenance_window={
        "hour_of_day": 2,
        "day_of_week": "SUNDAY",
    },
    hive_metastore_config={
        "version": "2.3.6",
    },
    labels={
        "env": "test",
    })

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

return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.Dataproc.MetastoreService("default", new()
    {
        ServiceId = "metastore-srv",
        Location = "us-central1",
        Port = 9080,
        Tier = "DEVELOPER",
        DeletionProtection = true,
        MaintenanceWindow = new Gcp.Dataproc.Inputs.MetastoreServiceMaintenanceWindowArgs
        {
            HourOfDay = 2,
            DayOfWeek = "SUNDAY",
        },
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "2.3.6",
        },
        Labels =
        {
            { "env", "test" },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "default", &dataproc.MetastoreServiceArgs{
			ServiceId:          pulumi.String("metastore-srv"),
			Location:           pulumi.String("us-central1"),
			Port:               pulumi.Int(9080),
			Tier:               pulumi.String("DEVELOPER"),
			DeletionProtection: pulumi.Bool(true),
			MaintenanceWindow: &dataproc.MetastoreServiceMaintenanceWindowArgs{
				HourOfDay: pulumi.Int(2),
				DayOfWeek: pulumi.String("SUNDAY"),
			},
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("2.3.6"),
			},
			Labels: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "default" {
  service_id          = "metastore-srv"
  location            = "us-central1"
  port                = 9080
  tier                = "DEVELOPER"
  deletion_protection = true
  maintenance_window = {
    hour_of_day = 2
    day_of_week = "SUNDAY"
  }
  hive_metastore_config = {
    version = "2.3.6"
  }
  labels = {
    "env" = "test"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceMaintenanceWindowArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var default_ = new MetastoreService("default", MetastoreServiceArgs.builder()
            .serviceId("metastore-srv")
            .location("us-central1")
            .port(9080)
            .tier("DEVELOPER")
            .deletionProtection(true)
            .maintenanceWindow(MetastoreServiceMaintenanceWindowArgs.builder()
                .hourOfDay(2)
                .dayOfWeek("SUNDAY")
                .build())
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("2.3.6")
                .build())
            .labels(Map.of("env", "test"))
            .build());

    }
}

resources:
  default:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: metastore-srv
      location: us-central1
      port: 9080
      tier: DEVELOPER
      deletionProtection: true
      maintenanceWindow:
        hourOfDay: 2
        dayOfWeek: SUNDAY
      hiveMetastoreConfig:
        version: 2.3.6
      labels:
        env: test

Dataproc Metastore Service Cmek Example

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

const keyRing = new gcp.kms.KeyRing("key_ring", {
    name: "example-keyring",
    location: "us-central1",
});
const cryptoKey = new gcp.kms.CryptoKey("crypto_key", {
    name: "example-key",
    keyRing: keyRing.id,
    purpose: "ENCRYPT_DECRYPT",
});
const _default = new gcp.dataproc.MetastoreService("default", {
    serviceId: "example-service",
    location: "us-central1",
    encryptionConfig: {
        kmsKey: cryptoKey.id,
    },
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
});

import pulumi
import pulumi_gcp as gcp

key_ring = gcp.kms.KeyRing("key_ring",
    name="example-keyring",
    location="us-central1")
crypto_key = gcp.kms.CryptoKey("crypto_key",
    name="example-key",
    key_ring=key_ring.id,
    purpose="ENCRYPT_DECRYPT")
default = gcp.dataproc.MetastoreService("default",
    service_id="example-service",
    location="us-central1",
    encryption_config={
        "kms_key": crypto_key.id,
    },
    hive_metastore_config={
        "version": "3.1.2",
    })

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

return await Deployment.RunAsync(() =>
{
    var keyRing = new Gcp.Kms.KeyRing("key_ring", new()
    {
        Name = "example-keyring",
        Location = "us-central1",
    });

    var cryptoKey = new Gcp.Kms.CryptoKey("crypto_key", new()
    {
        Name = "example-key",
        KeyRing = keyRing.Id,
        Purpose = "ENCRYPT_DECRYPT",
    });

    var @default = new Gcp.Dataproc.MetastoreService("default", new()
    {
        ServiceId = "example-service",
        Location = "us-central1",
        EncryptionConfig = new Gcp.Dataproc.Inputs.MetastoreServiceEncryptionConfigArgs
        {
            KmsKey = cryptoKey.Id,
        },
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		keyRing, err := kms.NewKeyRing(ctx, "key_ring", &kms.KeyRingArgs{
			Name:     pulumi.String("example-keyring"),
			Location: pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		cryptoKey, err := kms.NewCryptoKey(ctx, "crypto_key", &kms.CryptoKeyArgs{
			Name:    pulumi.String("example-key"),
			KeyRing: keyRing.ID().ToIDOutput().ToStringOutput(),
			Purpose: pulumi.String("ENCRYPT_DECRYPT"),
		})
		if err != nil {
			return err
		}
		_, err = dataproc.NewMetastoreService(ctx, "default", &dataproc.MetastoreServiceArgs{
			ServiceId: pulumi.String("example-service"),
			Location:  pulumi.String("us-central1"),
			EncryptionConfig: &dataproc.MetastoreServiceEncryptionConfigArgs{
				KmsKey: cryptoKey.ID().ToIDOutput().ToStringOutput(),
			},
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "default" {
  service_id = "example-service"
  location   = "us-central1"
  encryption_config = {
    kms_key = gcp_kms_cryptokey.crypto_key.id
  }
  hive_metastore_config = {
    version = "3.1.2"
  }
}
resource "gcp_kms_cryptokey" "crypto_key" {
  name     = "example-key"
  key_ring = gcp_kms_keyring.key_ring.id
  purpose  = "ENCRYPT_DECRYPT"
}
resource "gcp_kms_keyring" "key_ring" {
  name     = "example-keyring"
  location = "us-central1"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceEncryptionConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var keyRing = new KeyRing("keyRing", KeyRingArgs.builder()
            .name("example-keyring")
            .location("us-central1")
            .build());

        var cryptoKey = new CryptoKey("cryptoKey", CryptoKeyArgs.builder()
            .name("example-key")
            .keyRing(keyRing.id())
            .purpose("ENCRYPT_DECRYPT")
            .build());

        var default_ = new MetastoreService("default", MetastoreServiceArgs.builder()
            .serviceId("example-service")
            .location("us-central1")
            .encryptionConfig(MetastoreServiceEncryptionConfigArgs.builder()
                .kmsKey(cryptoKey.id())
                .build())
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .build());

    }
}

resources:
  default:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: example-service
      location: us-central1
      encryptionConfig:
        kmsKey: ${cryptoKey.id}
      hiveMetastoreConfig:
        version: 3.1.2
  cryptoKey:
    type: gcp:kms:CryptoKey
    name: crypto_key
    properties:
      name: example-key
      keyRing: ${keyRing.id}
      purpose: ENCRYPT_DECRYPT
  keyRing:
    type: gcp:kms:KeyRing
    name: key_ring
    properties:
      name: example-keyring
      location: us-central1

Dataproc Metastore Service Private Service Connect

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

const net = new gcp.compute.Network("net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const subnet = new gcp.compute.Subnetwork("subnet", {
    name: "my-subnetwork",
    region: "us-central1",
    network: net.id,
    ipCidrRange: "10.0.0.0/22",
    privateIpGoogleAccess: true,
});
const _default = new gcp.dataproc.MetastoreService("default", {
    serviceId: "metastore-srv",
    location: "us-central1",
    tier: "DEVELOPER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    networkConfig: {
        consumers: [{
            subnetwork: subnet.id,
        }],
    },
});

import pulumi
import pulumi_gcp as gcp

net = gcp.compute.Network("net",
    name="my-network",
    auto_create_subnetworks=False)
subnet = gcp.compute.Subnetwork("subnet",
    name="my-subnetwork",
    region="us-central1",
    network=net.id,
    ip_cidr_range="10.0.0.0/22",
    private_ip_google_access=True)
default = gcp.dataproc.MetastoreService("default",
    service_id="metastore-srv",
    location="us-central1",
    tier="DEVELOPER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    network_config={
        "consumers": [{
            "subnetwork": subnet.id,
        }],
    })

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

return await Deployment.RunAsync(() =>
{
    var net = new Gcp.Compute.Network("net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var subnet = new Gcp.Compute.Subnetwork("subnet", new()
    {
        Name = "my-subnetwork",
        Region = "us-central1",
        Network = net.Id,
        IpCidrRange = "10.0.0.0/22",
        PrivateIpGoogleAccess = true,
    });

    var @default = new Gcp.Dataproc.MetastoreService("default", new()
    {
        ServiceId = "metastore-srv",
        Location = "us-central1",
        Tier = "DEVELOPER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        NetworkConfig = new Gcp.Dataproc.Inputs.MetastoreServiceNetworkConfigArgs
        {
            Consumers = new[]
            {
                new Gcp.Dataproc.Inputs.MetastoreServiceNetworkConfigConsumerArgs
                {
                    Subnetwork = subnet.Id,
                },
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		net, err := compute.NewNetwork(ctx, "net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		subnet, err := compute.NewSubnetwork(ctx, "subnet", &compute.SubnetworkArgs{
			Name:                  pulumi.String("my-subnetwork"),
			Region:                pulumi.String("us-central1"),
			Network:               net.ID().ToIDOutput().ToStringOutput(),
			IpCidrRange:           pulumi.String("10.0.0.0/22"),
			PrivateIpGoogleAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = dataproc.NewMetastoreService(ctx, "default", &dataproc.MetastoreServiceArgs{
			ServiceId: pulumi.String("metastore-srv"),
			Location:  pulumi.String("us-central1"),
			Tier:      pulumi.String("DEVELOPER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			NetworkConfig: &dataproc.MetastoreServiceNetworkConfigArgs{
				Consumers: dataproc.MetastoreServiceNetworkConfigConsumerArray{
					&dataproc.MetastoreServiceNetworkConfigConsumerArgs{
						Subnetwork: subnet.ID().ToIDOutput().ToStringOutput(),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_compute_network" "net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "subnet" {
  name                     = "my-subnetwork"
  region                   = "us-central1"
  network                  = gcp_compute_network.net.id
  ip_cidr_range            = "10.0.0.0/22"
  private_ip_google_access = true
}
resource "gcp_dataproc_metastoreservice" "default" {
  service_id = "metastore-srv"
  location   = "us-central1"
  tier       = "DEVELOPER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  network_config = {
    consumers = [{
      "subnetwork" = gcp_compute_subnetwork.subnet.id
    }]
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceNetworkConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceNetworkConfigConsumerArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var net = new Network("net", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var subnet = new Subnetwork("subnet", SubnetworkArgs.builder()
            .name("my-subnetwork")
            .region("us-central1")
            .network(net.id())
            .ipCidrRange("10.0.0.0/22")
            .privateIpGoogleAccess(true)
            .build());

        var default_ = new MetastoreService("default", MetastoreServiceArgs.builder()
            .serviceId("metastore-srv")
            .location("us-central1")
            .tier("DEVELOPER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .networkConfig(MetastoreServiceNetworkConfigArgs.builder()
                .consumers(MetastoreServiceNetworkConfigConsumerArgs.builder()
                    .subnetwork(subnet.id())
                    .build())
                .build())
            .build());

    }
}

resources:
  net:
    type: gcp:compute:Network
    properties:
      name: my-network
      autoCreateSubnetworks: false
  subnet:
    type: gcp:compute:Subnetwork
    properties:
      name: my-subnetwork
      region: us-central1
      network: ${net.id}
      ipCidrRange: 10.0.0.0/22
      privateIpGoogleAccess: true
  default:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: metastore-srv
      location: us-central1
      tier: DEVELOPER
      hiveMetastoreConfig:
        version: 3.1.2
      networkConfig:
        consumers:
          - subnetwork: ${subnet.id}

Dataproc Metastore Service Private Service Connect Custom Routes

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

const net = new gcp.compute.Network("net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const subnet = new gcp.compute.Subnetwork("subnet", {
    name: "my-subnetwork",
    region: "us-central1",
    network: net.id,
    ipCidrRange: "10.0.0.0/22",
    privateIpGoogleAccess: true,
});
const _default = new gcp.dataproc.MetastoreService("default", {
    serviceId: "metastore-srv",
    location: "us-central1",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    networkConfig: {
        consumers: [{
            subnetwork: subnet.id,
        }],
        customRoutesEnabled: true,
    },
});

import pulumi
import pulumi_gcp as gcp

net = gcp.compute.Network("net",
    name="my-network",
    auto_create_subnetworks=False)
subnet = gcp.compute.Subnetwork("subnet",
    name="my-subnetwork",
    region="us-central1",
    network=net.id,
    ip_cidr_range="10.0.0.0/22",
    private_ip_google_access=True)
default = gcp.dataproc.MetastoreService("default",
    service_id="metastore-srv",
    location="us-central1",
    hive_metastore_config={
        "version": "3.1.2",
    },
    network_config={
        "consumers": [{
            "subnetwork": subnet.id,
        }],
        "custom_routes_enabled": True,
    })

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

return await Deployment.RunAsync(() =>
{
    var net = new Gcp.Compute.Network("net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var subnet = new Gcp.Compute.Subnetwork("subnet", new()
    {
        Name = "my-subnetwork",
        Region = "us-central1",
        Network = net.Id,
        IpCidrRange = "10.0.0.0/22",
        PrivateIpGoogleAccess = true,
    });

    var @default = new Gcp.Dataproc.MetastoreService("default", new()
    {
        ServiceId = "metastore-srv",
        Location = "us-central1",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        NetworkConfig = new Gcp.Dataproc.Inputs.MetastoreServiceNetworkConfigArgs
        {
            Consumers = new[]
            {
                new Gcp.Dataproc.Inputs.MetastoreServiceNetworkConfigConsumerArgs
                {
                    Subnetwork = subnet.Id,
                },
            },
            CustomRoutesEnabled = true,
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		net, err := compute.NewNetwork(ctx, "net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		subnet, err := compute.NewSubnetwork(ctx, "subnet", &compute.SubnetworkArgs{
			Name:                  pulumi.String("my-subnetwork"),
			Region:                pulumi.String("us-central1"),
			Network:               net.ID().ToIDOutput().ToStringOutput(),
			IpCidrRange:           pulumi.String("10.0.0.0/22"),
			PrivateIpGoogleAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = dataproc.NewMetastoreService(ctx, "default", &dataproc.MetastoreServiceArgs{
			ServiceId: pulumi.String("metastore-srv"),
			Location:  pulumi.String("us-central1"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			NetworkConfig: &dataproc.MetastoreServiceNetworkConfigArgs{
				Consumers: dataproc.MetastoreServiceNetworkConfigConsumerArray{
					&dataproc.MetastoreServiceNetworkConfigConsumerArgs{
						Subnetwork: subnet.ID().ToIDOutput().ToStringOutput(),
					},
				},
				CustomRoutesEnabled: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_compute_network" "net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "subnet" {
  name                     = "my-subnetwork"
  region                   = "us-central1"
  network                  = gcp_compute_network.net.id
  ip_cidr_range            = "10.0.0.0/22"
  private_ip_google_access = true
}
resource "gcp_dataproc_metastoreservice" "default" {
  service_id = "metastore-srv"
  location   = "us-central1"
  hive_metastore_config = {
    version = "3.1.2"
  }
  network_config = {
    consumers = [{
      "subnetwork" = gcp_compute_subnetwork.subnet.id
    }]
    custom_routes_enabled = true
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceNetworkConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceNetworkConfigConsumerArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var net = new Network("net", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var subnet = new Subnetwork("subnet", SubnetworkArgs.builder()
            .name("my-subnetwork")
            .region("us-central1")
            .network(net.id())
            .ipCidrRange("10.0.0.0/22")
            .privateIpGoogleAccess(true)
            .build());

        var default_ = new MetastoreService("default", MetastoreServiceArgs.builder()
            .serviceId("metastore-srv")
            .location("us-central1")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .networkConfig(MetastoreServiceNetworkConfigArgs.builder()
                .consumers(MetastoreServiceNetworkConfigConsumerArgs.builder()
                    .subnetwork(subnet.id())
                    .build())
                .customRoutesEnabled(true)
                .build())
            .build());

    }
}

resources:
  net:
    type: gcp:compute:Network
    properties:
      name: my-network
      autoCreateSubnetworks: false
  subnet:
    type: gcp:compute:Subnetwork
    properties:
      name: my-subnetwork
      region: us-central1
      network: ${net.id}
      ipCidrRange: 10.0.0.0/22
      privateIpGoogleAccess: true
  default:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: metastore-srv
      location: us-central1
      hiveMetastoreConfig:
        version: 3.1.2
      networkConfig:
        consumers:
          - subnetwork: ${subnet.id}
        customRoutesEnabled: true

Dataproc Metastore Service Dpms2

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

const dpms2 = new gcp.dataproc.MetastoreService("dpms2", {
    serviceId: "ms-dpms2",
    location: "us-central1",
    databaseType: "SPANNER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    scalingConfig: {
        instanceSize: "EXTRA_SMALL",
    },
});

import pulumi
import pulumi_gcp as gcp

dpms2 = gcp.dataproc.MetastoreService("dpms2",
    service_id="ms-dpms2",
    location="us-central1",
    database_type="SPANNER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    scaling_config={
        "instance_size": "EXTRA_SMALL",
    })

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

return await Deployment.RunAsync(() =>
{
    var dpms2 = new Gcp.Dataproc.MetastoreService("dpms2", new()
    {
        ServiceId = "ms-dpms2",
        Location = "us-central1",
        DatabaseType = "SPANNER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        ScalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigArgs
        {
            InstanceSize = "EXTRA_SMALL",
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "dpms2", &dataproc.MetastoreServiceArgs{
			ServiceId:    pulumi.String("ms-dpms2"),
			Location:     pulumi.String("us-central1"),
			DatabaseType: pulumi.String("SPANNER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			ScalingConfig: &dataproc.MetastoreServiceScalingConfigArgs{
				InstanceSize: pulumi.String("EXTRA_SMALL"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "dpms2" {
  service_id    = "ms-dpms2"
  location      = "us-central1"
  database_type = "SPANNER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  scaling_config = {
    instance_size = "EXTRA_SMALL"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var dpms2 = new MetastoreService("dpms2", MetastoreServiceArgs.builder()
            .serviceId("ms-dpms2")
            .location("us-central1")
            .databaseType("SPANNER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .scalingConfig(MetastoreServiceScalingConfigArgs.builder()
                .instanceSize("EXTRA_SMALL")
                .build())
            .build());

    }
}

resources:
  dpms2:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: ms-dpms2
      location: us-central1
      databaseType: SPANNER
      hiveMetastoreConfig:
        version: 3.1.2
      scalingConfig:
        instanceSize: EXTRA_SMALL

Dataproc Metastore Service Dpms2 Scaling Factor

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

const dpms2ScalingFactor = new gcp.dataproc.MetastoreService("dpms2_scaling_factor", {
    serviceId: "ms-dpms2sf",
    location: "us-central1",
    databaseType: "SPANNER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    scalingConfig: {
        scalingFactor: 2,
    },
});

import pulumi
import pulumi_gcp as gcp

dpms2_scaling_factor = gcp.dataproc.MetastoreService("dpms2_scaling_factor",
    service_id="ms-dpms2sf",
    location="us-central1",
    database_type="SPANNER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    scaling_config={
        "scaling_factor": float(2),
    })

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

return await Deployment.RunAsync(() =>
{
    var dpms2ScalingFactor = new Gcp.Dataproc.MetastoreService("dpms2_scaling_factor", new()
    {
        ServiceId = "ms-dpms2sf",
        Location = "us-central1",
        DatabaseType = "SPANNER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        ScalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigArgs
        {
            ScalingFactor = 2.0,
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "dpms2_scaling_factor", &dataproc.MetastoreServiceArgs{
			ServiceId:    pulumi.String("ms-dpms2sf"),
			Location:     pulumi.String("us-central1"),
			DatabaseType: pulumi.String("SPANNER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			ScalingConfig: &dataproc.MetastoreServiceScalingConfigArgs{
				ScalingFactor: pulumi.Float64(2),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "dpms2_scaling_factor" {
  service_id    = "ms-dpms2sf"
  location      = "us-central1"
  database_type = "SPANNER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  scaling_config = {
    scaling_factor = "2"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var dpms2ScalingFactor = new MetastoreService("dpms2ScalingFactor", MetastoreServiceArgs.builder()
            .serviceId("ms-dpms2sf")
            .location("us-central1")
            .databaseType("SPANNER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .scalingConfig(MetastoreServiceScalingConfigArgs.builder()
                .scalingFactor(2.0)
                .build())
            .build());

    }
}

resources:
  dpms2ScalingFactor:
    type: gcp:dataproc:MetastoreService
    name: dpms2_scaling_factor
    properties:
      serviceId: ms-dpms2sf
      location: us-central1
      databaseType: SPANNER
      hiveMetastoreConfig:
        version: 3.1.2
      scalingConfig:
        scalingFactor: '2'

Dataproc Metastore Service Scheduled Backup

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

const bucket = new gcp.storage.Bucket("bucket", {
    name: "backup-1",
    location: "us-central1",
});
const backup = new gcp.dataproc.MetastoreService("backup", {
    serviceId: "backup-1",
    location: "us-central1",
    port: 9080,
    tier: "DEVELOPER",
    maintenanceWindow: {
        hourOfDay: 2,
        dayOfWeek: "SUNDAY",
    },
    hiveMetastoreConfig: {
        version: "2.3.6",
    },
    scheduledBackup: {
        enabled: true,
        cronSchedule: "0 0 * * *",
        timeZone: "UTC",
        backupLocation: pulumi.interpolate`gs://${bucket.name}`,
    },
    labels: {
        env: "test",
    },
});

import pulumi
import pulumi_gcp as gcp

bucket = gcp.storage.Bucket("bucket",
    name="backup-1",
    location="us-central1")
backup = gcp.dataproc.MetastoreService("backup",
    service_id="backup-1",
    location="us-central1",
    port=9080,
    tier="DEVELOPER",
    maintenance_window={
        "hour_of_day": 2,
        "day_of_week": "SUNDAY",
    },
    hive_metastore_config={
        "version": "2.3.6",
    },
    scheduled_backup={
        "enabled": True,
        "cron_schedule": "0 0 * * *",
        "time_zone": "UTC",
        "backup_location": bucket.name.apply(lambda name: f"gs://{name}"),
    },
    labels={
        "env": "test",
    })

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 = "backup-1",
        Location = "us-central1",
    });

    var backup = new Gcp.Dataproc.MetastoreService("backup", new()
    {
        ServiceId = "backup-1",
        Location = "us-central1",
        Port = 9080,
        Tier = "DEVELOPER",
        MaintenanceWindow = new Gcp.Dataproc.Inputs.MetastoreServiceMaintenanceWindowArgs
        {
            HourOfDay = 2,
            DayOfWeek = "SUNDAY",
        },
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "2.3.6",
        },
        ScheduledBackup = new Gcp.Dataproc.Inputs.MetastoreServiceScheduledBackupArgs
        {
            Enabled = true,
            CronSchedule = "0 0 * * *",
            TimeZone = "UTC",
            BackupLocation = bucket.Name.Apply(name => $"gs://{name}"),
        },
        Labels =
        {
            { "env", "test" },
        },
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataproc"
	"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("backup-1"),
			Location: pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_, err = dataproc.NewMetastoreService(ctx, "backup", &dataproc.MetastoreServiceArgs{
			ServiceId: pulumi.String("backup-1"),
			Location:  pulumi.String("us-central1"),
			Port:      pulumi.Int(9080),
			Tier:      pulumi.String("DEVELOPER"),
			MaintenanceWindow: &dataproc.MetastoreServiceMaintenanceWindowArgs{
				HourOfDay: pulumi.Int(2),
				DayOfWeek: pulumi.String("SUNDAY"),
			},
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("2.3.6"),
			},
			ScheduledBackup: &dataproc.MetastoreServiceScheduledBackupArgs{
				Enabled:      pulumi.Bool(true),
				CronSchedule: pulumi.String("0 0 * * *"),
				TimeZone:     pulumi.String("UTC"),
				BackupLocation: bucket.Name.ApplyT(func(name string) (string, error) {
					return fmt.Sprintf("gs://%v", name), nil
				}).(pulumi.StringOutput),
			},
			Labels: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "backup" {
  service_id = "backup-1"
  location   = "us-central1"
  port       = 9080
  tier       = "DEVELOPER"
  maintenance_window = {
    hour_of_day = 2
    day_of_week = "SUNDAY"
  }
  hive_metastore_config = {
    version = "2.3.6"
  }
  scheduled_backup = {
    enabled         = true
    cron_schedule   = "0 0 * * *"
    time_zone       = "UTC"
    backup_location ="gs://${gcp_storage_bucket.bucket.name}"
  }
  labels = {
    "env" = "test"
  }
}
resource "gcp_storage_bucket" "bucket" {
  name     = "backup-1"
  location = "us-central1"
}

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.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceMaintenanceWindowArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScheduledBackupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var bucket = new Bucket("bucket", BucketArgs.builder()
            .name("backup-1")
            .location("us-central1")
            .build());

        var backup = new MetastoreService("backup", MetastoreServiceArgs.builder()
            .serviceId("backup-1")
            .location("us-central1")
            .port(9080)
            .tier("DEVELOPER")
            .maintenanceWindow(MetastoreServiceMaintenanceWindowArgs.builder()
                .hourOfDay(2)
                .dayOfWeek("SUNDAY")
                .build())
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("2.3.6")
                .build())
            .scheduledBackup(MetastoreServiceScheduledBackupArgs.builder()
                .enabled(true)
                .cronSchedule("0 0 * * *")
                .timeZone("UTC")
                .backupLocation(bucket.name().applyValue(_name -> String.format("gs://%s", _name)))
                .build())
            .labels(Map.of("env", "test"))
            .build());

    }
}

resources:
  backup:
    type: gcp:dataproc:MetastoreService
    properties:
      serviceId: backup-1
      location: us-central1
      port: 9080
      tier: DEVELOPER
      maintenanceWindow:
        hourOfDay: 2
        dayOfWeek: SUNDAY
      hiveMetastoreConfig:
        version: 2.3.6
      scheduledBackup:
        enabled: true
        cronSchedule: 0 0 * * *
        timeZone: UTC
        backupLocation: gs://${bucket.name}
      labels:
        env: test
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: backup-1
      location: us-central1

Dataproc Metastore Service Autoscaling Max Scaling Factor

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

const testResource = new gcp.dataproc.MetastoreService("test_resource", {
    serviceId: "test-service",
    location: "us-central1",
    databaseType: "SPANNER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    scalingConfig: {
        autoscalingConfig: {
            autoscalingEnabled: true,
            limitConfig: {
                maxScalingFactor: 1,
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

test_resource = gcp.dataproc.MetastoreService("test_resource",
    service_id="test-service",
    location="us-central1",
    database_type="SPANNER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    scaling_config={
        "autoscaling_config": {
            "autoscaling_enabled": True,
            "limit_config": {
                "max_scaling_factor": float(1),
            },
        },
    })

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

return await Deployment.RunAsync(() =>
{
    var testResource = new Gcp.Dataproc.MetastoreService("test_resource", new()
    {
        ServiceId = "test-service",
        Location = "us-central1",
        DatabaseType = "SPANNER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        ScalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigArgs
        {
            AutoscalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs
            {
                AutoscalingEnabled = true,
                LimitConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs
                {
                    MaxScalingFactor = 1.0,
                },
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "test_resource", &dataproc.MetastoreServiceArgs{
			ServiceId:    pulumi.String("test-service"),
			Location:     pulumi.String("us-central1"),
			DatabaseType: pulumi.String("SPANNER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			ScalingConfig: &dataproc.MetastoreServiceScalingConfigArgs{
				AutoscalingConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs{
					AutoscalingEnabled: pulumi.Bool(true),
					LimitConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs{
						MaxScalingFactor: pulumi.Float64(1),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "test_resource" {
  service_id    = "test-service"
  location      = "us-central1"
  database_type = "SPANNER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  scaling_config = {
    autoscaling_config = {
      autoscaling_enabled = true
      limit_config = {
        max_scaling_factor = 1
      }
    }
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var testResource = new MetastoreService("testResource", MetastoreServiceArgs.builder()
            .serviceId("test-service")
            .location("us-central1")
            .databaseType("SPANNER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .scalingConfig(MetastoreServiceScalingConfigArgs.builder()
                .autoscalingConfig(MetastoreServiceScalingConfigAutoscalingConfigArgs.builder()
                    .autoscalingEnabled(true)
                    .limitConfig(MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs.builder()
                        .maxScalingFactor(1.0)
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  testResource:
    type: gcp:dataproc:MetastoreService
    name: test_resource
    properties:
      serviceId: test-service
      location: us-central1
      databaseType: SPANNER
      hiveMetastoreConfig:
        version: 3.1.2
      scalingConfig:
        autoscalingConfig:
          autoscalingEnabled: true
          limitConfig:
            maxScalingFactor: 1

Dataproc Metastore Service Autoscaling Min And Max Scaling Factor

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

const testResource = new gcp.dataproc.MetastoreService("test_resource", {
    serviceId: "test-service",
    location: "us-central1",
    databaseType: "SPANNER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    scalingConfig: {
        autoscalingConfig: {
            autoscalingEnabled: true,
            limitConfig: {
                minScalingFactor: 0.1,
                maxScalingFactor: 1,
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

test_resource = gcp.dataproc.MetastoreService("test_resource",
    service_id="test-service",
    location="us-central1",
    database_type="SPANNER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    scaling_config={
        "autoscaling_config": {
            "autoscaling_enabled": True,
            "limit_config": {
                "min_scaling_factor": 0.1,
                "max_scaling_factor": float(1),
            },
        },
    })

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

return await Deployment.RunAsync(() =>
{
    var testResource = new Gcp.Dataproc.MetastoreService("test_resource", new()
    {
        ServiceId = "test-service",
        Location = "us-central1",
        DatabaseType = "SPANNER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        ScalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigArgs
        {
            AutoscalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs
            {
                AutoscalingEnabled = true,
                LimitConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs
                {
                    MinScalingFactor = 0.1,
                    MaxScalingFactor = 1.0,
                },
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "test_resource", &dataproc.MetastoreServiceArgs{
			ServiceId:    pulumi.String("test-service"),
			Location:     pulumi.String("us-central1"),
			DatabaseType: pulumi.String("SPANNER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			ScalingConfig: &dataproc.MetastoreServiceScalingConfigArgs{
				AutoscalingConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs{
					AutoscalingEnabled: pulumi.Bool(true),
					LimitConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs{
						MinScalingFactor: pulumi.Float64(0.1),
						MaxScalingFactor: pulumi.Float64(1),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "test_resource" {
  service_id    = "test-service"
  location      = "us-central1"
  database_type = "SPANNER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  scaling_config = {
    autoscaling_config = {
      autoscaling_enabled = true
      limit_config = {
        min_scaling_factor = 0.1
        max_scaling_factor = 1
      }
    }
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var testResource = new MetastoreService("testResource", MetastoreServiceArgs.builder()
            .serviceId("test-service")
            .location("us-central1")
            .databaseType("SPANNER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .scalingConfig(MetastoreServiceScalingConfigArgs.builder()
                .autoscalingConfig(MetastoreServiceScalingConfigAutoscalingConfigArgs.builder()
                    .autoscalingEnabled(true)
                    .limitConfig(MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs.builder()
                        .minScalingFactor(0.1)
                        .maxScalingFactor(1.0)
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  testResource:
    type: gcp:dataproc:MetastoreService
    name: test_resource
    properties:
      serviceId: test-service
      location: us-central1
      databaseType: SPANNER
      hiveMetastoreConfig:
        version: 3.1.2
      scalingConfig:
        autoscalingConfig:
          autoscalingEnabled: true
          limitConfig:
            minScalingFactor: 0.1
            maxScalingFactor: 1

Dataproc Metastore Service Autoscaling Min Scaling Factor

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

const testResource = new gcp.dataproc.MetastoreService("test_resource", {
    serviceId: "test-service",
    location: "us-central1",
    databaseType: "SPANNER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    scalingConfig: {
        autoscalingConfig: {
            autoscalingEnabled: true,
            limitConfig: {
                minScalingFactor: 0.1,
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

test_resource = gcp.dataproc.MetastoreService("test_resource",
    service_id="test-service",
    location="us-central1",
    database_type="SPANNER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    scaling_config={
        "autoscaling_config": {
            "autoscaling_enabled": True,
            "limit_config": {
                "min_scaling_factor": 0.1,
            },
        },
    })

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

return await Deployment.RunAsync(() =>
{
    var testResource = new Gcp.Dataproc.MetastoreService("test_resource", new()
    {
        ServiceId = "test-service",
        Location = "us-central1",
        DatabaseType = "SPANNER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        ScalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigArgs
        {
            AutoscalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs
            {
                AutoscalingEnabled = true,
                LimitConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs
                {
                    MinScalingFactor = 0.1,
                },
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "test_resource", &dataproc.MetastoreServiceArgs{
			ServiceId:    pulumi.String("test-service"),
			Location:     pulumi.String("us-central1"),
			DatabaseType: pulumi.String("SPANNER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			ScalingConfig: &dataproc.MetastoreServiceScalingConfigArgs{
				AutoscalingConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs{
					AutoscalingEnabled: pulumi.Bool(true),
					LimitConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs{
						MinScalingFactor: pulumi.Float64(0.1),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "test_resource" {
  service_id    = "test-service"
  location      = "us-central1"
  database_type = "SPANNER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  scaling_config = {
    autoscaling_config = {
      autoscaling_enabled = true
      limit_config = {
        min_scaling_factor = 0.1
      }
    }
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var testResource = new MetastoreService("testResource", MetastoreServiceArgs.builder()
            .serviceId("test-service")
            .location("us-central1")
            .databaseType("SPANNER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .scalingConfig(MetastoreServiceScalingConfigArgs.builder()
                .autoscalingConfig(MetastoreServiceScalingConfigAutoscalingConfigArgs.builder()
                    .autoscalingEnabled(true)
                    .limitConfig(MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs.builder()
                        .minScalingFactor(0.1)
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  testResource:
    type: gcp:dataproc:MetastoreService
    name: test_resource
    properties:
      serviceId: test-service
      location: us-central1
      databaseType: SPANNER
      hiveMetastoreConfig:
        version: 3.1.2
      scalingConfig:
        autoscalingConfig:
          autoscalingEnabled: true
          limitConfig:
            minScalingFactor: 0.1

Dataproc Metastore Service Autoscaling No Limit Config

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

const testResource = new gcp.dataproc.MetastoreService("test_resource", {
    serviceId: "test-service",
    location: "us-central1",
    databaseType: "SPANNER",
    hiveMetastoreConfig: {
        version: "3.1.2",
    },
    scalingConfig: {
        autoscalingConfig: {
            autoscalingEnabled: true,
        },
    },
});

import pulumi
import pulumi_gcp as gcp

test_resource = gcp.dataproc.MetastoreService("test_resource",
    service_id="test-service",
    location="us-central1",
    database_type="SPANNER",
    hive_metastore_config={
        "version": "3.1.2",
    },
    scaling_config={
        "autoscaling_config": {
            "autoscaling_enabled": True,
        },
    })

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

return await Deployment.RunAsync(() =>
{
    var testResource = new Gcp.Dataproc.MetastoreService("test_resource", new()
    {
        ServiceId = "test-service",
        Location = "us-central1",
        DatabaseType = "SPANNER",
        HiveMetastoreConfig = new Gcp.Dataproc.Inputs.MetastoreServiceHiveMetastoreConfigArgs
        {
            Version = "3.1.2",
        },
        ScalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigArgs
        {
            AutoscalingConfig = new Gcp.Dataproc.Inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs
            {
                AutoscalingEnabled = true,
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataproc.NewMetastoreService(ctx, "test_resource", &dataproc.MetastoreServiceArgs{
			ServiceId:    pulumi.String("test-service"),
			Location:     pulumi.String("us-central1"),
			DatabaseType: pulumi.String("SPANNER"),
			HiveMetastoreConfig: &dataproc.MetastoreServiceHiveMetastoreConfigArgs{
				Version: pulumi.String("3.1.2"),
			},
			ScalingConfig: &dataproc.MetastoreServiceScalingConfigArgs{
				AutoscalingConfig: &dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs{
					AutoscalingEnabled: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

resource "gcp_dataproc_metastoreservice" "test_resource" {
  service_id    = "test-service"
  location      = "us-central1"
  database_type = "SPANNER"
  hive_metastore_config = {
    version = "3.1.2"
  }
  scaling_config = {
    autoscaling_config = {
      autoscaling_enabled = true
    }
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.MetastoreService;
import com.pulumi.gcp.dataproc.MetastoreServiceArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceHiveMetastoreConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigArgs;
import com.pulumi.gcp.dataproc.inputs.MetastoreServiceScalingConfigAutoscalingConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var testResource = new MetastoreService("testResource", MetastoreServiceArgs.builder()
            .serviceId("test-service")
            .location("us-central1")
            .databaseType("SPANNER")
            .hiveMetastoreConfig(MetastoreServiceHiveMetastoreConfigArgs.builder()
                .version("3.1.2")
                .build())
            .scalingConfig(MetastoreServiceScalingConfigArgs.builder()
                .autoscalingConfig(MetastoreServiceScalingConfigAutoscalingConfigArgs.builder()
                    .autoscalingEnabled(true)
                    .build())
                .build())
            .build());

    }
}

resources:
  testResource:
    type: gcp:dataproc:MetastoreService
    name: test_resource
    properties:
      serviceId: test-service
      location: us-central1
      databaseType: SPANNER
      hiveMetastoreConfig:
        version: 3.1.2
      scalingConfig:
        autoscalingConfig:
          autoscalingEnabled: true

Import

Service can be imported using any of these accepted formats:

projects/{{project}}/locations/{{location}}/services/{{service_id}}
{{project}}/{{location}}/{{service_id}}
{{location}}/{{service_id}}

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

$ pulumi import gcp:dataproc/metastoreService:MetastoreService default projects/{{project}}/locations/{{location}}/services/{{service_id}}
$ pulumi import gcp:dataproc/metastoreService:MetastoreService default {{project}}/{{location}}/{{service_id}}
$ pulumi import gcp:dataproc/metastoreService:MetastoreService default {{location}}/{{service_id}}

Constructors

MetastoreService(String name, {MetastoreServiceArgs? args, CustomResourceOptions? options}): Creates a new MetastoreService. name The Pulumi resource name. args Arguments used to configure this MetastoreService. The set of arguments for MetastoreService. options Resource options controlling this resource's behavior.
MetastoreService.reference(String urn): Creates a typed reference to an existing MetastoreService resource.

Properties

artifactGcsUri ↔ Output<String>: A Cloud Storage URI (starting with gs://) that specifies where artifacts related to the metastore service are stored.
latefinal
childResources → Set<Resource>: finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>: latefinalinherited
createTime ↔ Output<String>: Output only. The time when the metastore service was created.
latefinal
databaseType ↔ Output<String?>: The database type that the Metastore service stores its data. Default value is MYSQL. Possible values are: MYSQL, SPANNER.
latefinal
deletionPolicy ↔ Output<String>: Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
latefinal
deletionProtection ↔ Output<bool?>: Indicates if the dataproc metastore should be protected against accidental deletions.
latefinal
effectiveLabels ↔ Output<Map<String, String>>: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
latefinal
encryptionConfig ↔ Output<MetastoreServiceEncryptionConfig?>: Information used to configure the Dataproc Metastore service to encrypt customer data at rest. Structure is documented below.
latefinal
endpointUri ↔ Output<String>: The URI of the endpoint used to access the metastore service.
latefinal
hashCode → int: The hash code for this object.
no setterinherited
hiveMetastoreConfig ↔ Output<MetastoreServiceHiveMetastoreConfig?>: Configuration information specific to running Hive metastore software as the metastore service. Structure is documented below.
latefinal
id ↔ Output<String>: getter/setter pairinherited
isCustom → bool: Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool: Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool: Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool: Whether this instance represents a resource value returned over RPC.
finalinherited
labels ↔ Output<Map<String, String>?>: User-defined labels for the metastore service. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
latefinal
location ↔ Output<String?>: The location where the metastore service should reside. The default value is global.
latefinal
maintenanceWindow ↔ Output<MetastoreServiceMaintenanceWindow?>: The one hour maintenance window of the metastore service. This specifies when the service can be restarted for maintenance purposes in UTC time. Maintenance window is not needed for services with the SPANNER database type. Structure is documented below.
latefinal
metadataIntegration ↔ Output<MetastoreServiceMetadataIntegration?>: The setting that defines how metastore metadata should be integrated with external services and systems. Structure is documented below.
latefinal
name ↔ Output<String>: The relative resource name of the metastore service.
latefinal
network ↔ Output<String>: The relative resource name of the VPC network on which the instance can be accessed. It is specified in the following form: "projects/{projectNumber}/global/networks/{network_id}".
latefinal
networkConfig ↔ Output<MetastoreServiceNetworkConfig?>: The configuration specifying the network settings for the Dataproc Metastore service. Structure is documented below.
latefinal
port ↔ Output<int>: The TCP port at which the metastore service is reached. Default: 9083.
latefinal
project ↔ Output<String>: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
latefinal
pulumiLabels ↔ Output<Map<String, String>>: The combination of labels configured directly on the resource and default labels configured on the provider.
latefinal
releaseChannel ↔ Output<String?>: The release channel of the service. If unspecified, defaults to STABLE. Default value is STABLE. Possible values are: CANARY, STABLE.
latefinal
resourceTransforms → List<ResourceTransform>: Inherited/explicit async transforms.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
scalingConfig ↔ Output<MetastoreServiceScalingConfig?>: Represents the scaling configuration of a metastore service. Structure is documented below.
latefinal
scheduledBackup ↔ Output<MetastoreServiceScheduledBackup?>: The configuration of scheduled backup for the metastore service. Structure is documented below.
latefinal
serviceId ↔ Output<String>: The ID of the metastore service. The id must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), and hyphens (-). Cannot begin or end with underscore or hyphen. Must consist of between 3 and 63 characters.
latefinal
state ↔ Output<String>: The current state of the metastore service.
latefinal
stateMessage ↔ Output<String>: Additional information about the current state of the metastore service, if available.
latefinal
tags ↔ Output<Map<String, String>?>: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/{tag_value_id}.
latefinal
telemetryConfig ↔ Output<MetastoreServiceTelemetryConfig>: The configuration specifying telemetry settings for the Dataproc Metastore service. If unspecified defaults to JSON. Structure is documented below.
latefinal
tier ↔ Output<String>: The tier of the service. Possible values are: DEVELOPER, ENTERPRISE.
latefinal
transformations → List<ResourceTransformation>: Inherited/explicit legacy transformations.
no setterinherited
uid ↔ Output<String>: The globally unique resource identifier of the metastore service.
latefinal
updateTime ↔ Output<String>: Output only. The time when the metastore service was last updated.
latefinal
urn ↔ Output<String>: latefinalinherited

Methods

failId(Object error) → void: Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void: Completes all output properties with error.
inherited
failUrn(Object error) → void: Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?: Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String: Returns this resource's logical name.
inherited
getResourceType() → String: Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>: Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void: Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void: Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void: Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>: Serializes resource properties for RPC transmission.
inherited
toString() → String: A string representation of this object.
inherited

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {MetastoreServiceState? state, CustomResourceOptions? options}) → MetastoreService: Gets an existing MetastoreService resource's state with the given name and id.