pulumi-gcp-kotlin/com.pulumi.gcp.firebase.kotlin/DatabaseInstance

DatabaseInstance

class DatabaseInstance : KotlinCustomResource

Example Usage

Firebase Database Instance Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const basic = new gcp.firebase.DatabaseInstance("basic", {
    project: "my-project-name",
    region: "us-central1",
    instanceId: "active-db",
});

import pulumi
import pulumi_gcp as gcp
basic = gcp.firebase.DatabaseInstance("basic",
    project="my-project-name",
    region="us-central1",
    instance_id="active-db")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var basic = new Gcp.Firebase.DatabaseInstance("basic", new()
    {
        Project = "my-project-name",
        Region = "us-central1",
        InstanceId = "active-db",
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/firebase"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := firebase.NewDatabaseInstance(ctx, "basic", &firebase.DatabaseInstanceArgs{
			Project:    pulumi.String("my-project-name"),
			Region:     pulumi.String("us-central1"),
			InstanceId: pulumi.String("active-db"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.firebase.DatabaseInstance;
import com.pulumi.gcp.firebase.DatabaseInstanceArgs;
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 basic = new DatabaseInstance("basic", DatabaseInstanceArgs.builder()
            .project("my-project-name")
            .region("us-central1")
            .instanceId("active-db")
            .build());
    }
}

resources:
  basic:
    type: gcp:firebase:DatabaseInstance
    properties:
      project: my-project-name
      region: us-central1
      instanceId: active-db

Firebase Database Instance Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const full = new gcp.firebase.DatabaseInstance("full", {
    project: "my-project-name",
    region: "europe-west1",
    instanceId: "disabled-db",
    type: "USER_DATABASE",
    desiredState: "DISABLED",
});

import pulumi
import pulumi_gcp as gcp
full = gcp.firebase.DatabaseInstance("full",
    project="my-project-name",
    region="europe-west1",
    instance_id="disabled-db",
    type="USER_DATABASE",
    desired_state="DISABLED")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var full = new Gcp.Firebase.DatabaseInstance("full", new()
    {
        Project = "my-project-name",
        Region = "europe-west1",
        InstanceId = "disabled-db",
        Type = "USER_DATABASE",
        DesiredState = "DISABLED",
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/firebase"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := firebase.NewDatabaseInstance(ctx, "full", &firebase.DatabaseInstanceArgs{
			Project:      pulumi.String("my-project-name"),
			Region:       pulumi.String("europe-west1"),
			InstanceId:   pulumi.String("disabled-db"),
			Type:         pulumi.String("USER_DATABASE"),
			DesiredState: pulumi.String("DISABLED"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.firebase.DatabaseInstance;
import com.pulumi.gcp.firebase.DatabaseInstanceArgs;
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 full = new DatabaseInstance("full", DatabaseInstanceArgs.builder()
            .project("my-project-name")
            .region("europe-west1")
            .instanceId("disabled-db")
            .type("USER_DATABASE")
            .desiredState("DISABLED")
            .build());
    }
}

resources:
  full:
    type: gcp:firebase:DatabaseInstance
    properties:
      project: my-project-name
      region: europe-west1
      instanceId: disabled-db
      type: USER_DATABASE
      desiredState: DISABLED

Firebase Database Instance Default Database

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.organizations.Project("default", {
    projectId: "rtdb-project",
    name: "rtdb-project",
    orgId: "123456789",
    labels: {
        firebase: "enabled",
    },
});
const defaultProject = new gcp.firebase.Project("default", {project: _default.projectId});
const firebaseDatabase = new gcp.projects.Service("firebase_database", {
    project: defaultProject.project,
    service: "firebasedatabase.googleapis.com",
});
const defaultDatabaseInstance = new gcp.firebase.DatabaseInstance("default", {
    project: defaultProject.project,
    region: "us-central1",
    instanceId: "rtdb-project-default-rtdb",
    type: "DEFAULT_DATABASE",
}, {
    dependsOn: [firebaseDatabase],
});

import pulumi
import pulumi_gcp as gcp
default = gcp.organizations.Project("default",
    project_id="rtdb-project",
    name="rtdb-project",
    org_id="123456789",
    labels={
        "firebase": "enabled",
    })
default_project = gcp.firebase.Project("default", project=default.project_id)
firebase_database = gcp.projects.Service("firebase_database",
    project=default_project.project,
    service="firebasedatabase.googleapis.com")
default_database_instance = gcp.firebase.DatabaseInstance("default",
    project=default_project.project,
    region="us-central1",
    instance_id="rtdb-project-default-rtdb",
    type="DEFAULT_DATABASE",
    opts = pulumi.ResourceOptions(depends_on=[firebase_database]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.Organizations.Project("default", new()
    {
        ProjectId = "rtdb-project",
        Name = "rtdb-project",
        OrgId = "123456789",
        Labels =
        {
            { "firebase", "enabled" },
        },
    });
    var defaultProject = new Gcp.Firebase.Project("default", new()
    {
        ProjectID = @default.ProjectId,
    });
    var firebaseDatabase = new Gcp.Projects.Service("firebase_database", new()
    {
        Project = defaultProject.ProjectID,
        ServiceName = "firebasedatabase.googleapis.com",
    });
    var defaultDatabaseInstance = new Gcp.Firebase.DatabaseInstance("default", new()
    {
        Project = defaultProject.ProjectID,
        Region = "us-central1",
        InstanceId = "rtdb-project-default-rtdb",
        Type = "DEFAULT_DATABASE",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            firebaseDatabase,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/firebase"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := organizations.NewProject(ctx, "default", &organizations.ProjectArgs{
			ProjectId: pulumi.String("rtdb-project"),
			Name:      pulumi.String("rtdb-project"),
			OrgId:     pulumi.String("123456789"),
			Labels: pulumi.StringMap{
				"firebase": pulumi.String("enabled"),
			},
		})
		if err != nil {
			return err
		}
		defaultProject, err := firebase.NewProject(ctx, "default", &firebase.ProjectArgs{
			Project: _default.ProjectId,
		})
		if err != nil {
			return err
		}
		firebaseDatabase, err := projects.NewService(ctx, "firebase_database", &projects.ServiceArgs{
			Project: defaultProject.Project,
			Service: pulumi.String("firebasedatabase.googleapis.com"),
		})
		if err != nil {
			return err
		}
		_, err = firebase.NewDatabaseInstance(ctx, "default", &firebase.DatabaseInstanceArgs{
			Project:    defaultProject.Project,
			Region:     pulumi.String("us-central1"),
			InstanceId: pulumi.String("rtdb-project-default-rtdb"),
			Type:       pulumi.String("DEFAULT_DATABASE"),
		}, pulumi.DependsOn([]pulumi.Resource{
			firebaseDatabase,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.firebase.Project;
import com.pulumi.gcp.firebase.ProjectArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumi.gcp.firebase.DatabaseInstance;
import com.pulumi.gcp.firebase.DatabaseInstanceArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var default_ = new Project("default", ProjectArgs.builder()
            .projectId("rtdb-project")
            .name("rtdb-project")
            .orgId("123456789")
            .labels(Map.of("firebase", "enabled"))
            .build());
        var defaultProject = new Project("defaultProject", ProjectArgs.builder()
            .project(default_.projectId())
            .build());
        var firebaseDatabase = new Service("firebaseDatabase", ServiceArgs.builder()
            .project(defaultProject.project())
            .service("firebasedatabase.googleapis.com")
            .build());
        var defaultDatabaseInstance = new DatabaseInstance("defaultDatabaseInstance", DatabaseInstanceArgs.builder()
            .project(defaultProject.project())
            .region("us-central1")
            .instanceId("rtdb-project-default-rtdb")
            .type("DEFAULT_DATABASE")
            .build(), CustomResourceOptions.builder()
                .dependsOn(firebaseDatabase)
                .build());
    }
}

resources:
  default:
    type: gcp:organizations:Project
    properties:
      projectId: rtdb-project
      name: rtdb-project
      orgId: '123456789'
      labels:
        firebase: enabled
  defaultProject:
    type: gcp:firebase:Project
    name: default
    properties:
      project: ${default.projectId}
  firebaseDatabase:
    type: gcp:projects:Service
    name: firebase_database
    properties:
      project: ${defaultProject.project}
      service: firebasedatabase.googleapis.com
  defaultDatabaseInstance:
    type: gcp:firebase:DatabaseInstance
    name: default
    properties:
      project: ${defaultProject.project}
      region: us-central1
      instanceId: rtdb-project-default-rtdb
      type: DEFAULT_DATABASE
    options:
      dependson:
        - ${firebaseDatabase}

Import

Instance can be imported using any of these accepted formats:

projects/{{project}}/locations/{{region}}/instances/{{instance_id}}
{{project}}/{{region}}/{{instance_id}}
{{region}}/{{instance_id}}
{{instance_id}} When using the pulumi import command, Instance can be imported using one of the formats above. For example:

$ pulumi import gcp:firebase/databaseInstance:DatabaseInstance default projects/{{project}}/locations/{{region}}/instances/{{instance_id}}

$ pulumi import gcp:firebase/databaseInstance:DatabaseInstance default {{project}}/{{region}}/{{instance_id}}

$ pulumi import gcp:firebase/databaseInstance:DatabaseInstance default {{region}}/{{instance_id}}

$ pulumi import gcp:firebase/databaseInstance:DatabaseInstance default {{instance_id}}

Properties

databaseUrl

val databaseUrl: Output<String>

The database URL in the form of https://{instance-id}.firebaseio.com for us-central1 instances or https://{instance-id}.{region}.firebasedatabase.app in other regions.

desiredState

val desiredState: Output<String>?

The intended database state.

val id: Output<String>

instanceId

val instanceId: Output<String>

The globally unique identifier of the Firebase Realtime Database instance. Instance IDs cannot be reused after deletion.

name

val name: Output<String>

The fully-qualified resource name of the Firebase Realtime Database, in the format: projects/PROJECT_NUMBER/locations/REGION_IDENTIFIER/instances/INSTANCE_ID PROJECT_NUMBER: The Firebase project's ProjectNumber Learn more about using project identifiers in Google's AIP 2510 standard.

project

val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

region

val region: Output<String>

A reference to the region where the Firebase Realtime database resides. Check all available regions

state

val state: Output<String>

The current database state. Set desired_state to :DISABLED to disable the database and :ACTIVE to reenable the database

type

val type: Output<String>?

The database type. Each project can create one default Firebase Realtime Database, which cannot be deleted once created. Creating user Databases is only available for projects on the Blaze plan. Projects can be upgraded using the Cloud Billing API https://cloud.google.com/billing/reference/rest/v1/projects/updateBillingInfo. Default value is USER_DATABASE. Possible values are: DEFAULT_DATABASE, USER_DATABASE.

urn

val urn: Output<String>