pulumi-gcp-kotlin/com.pulumi.gcp.oracledatabase.kotlin/AutonomousDatabase

AutonomousDatabase

class AutonomousDatabase : KotlinCustomResource

An AutonomousDatabase resource. To get more information about AutonomousDatabase, see:

Example Usage

Oracledatabase Autonomous Database Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = gcp.compute.getNetwork({
    name: "new",
    project: "my-project",
});
const myADB = new gcp.oracledatabase.AutonomousDatabase("myADB", {
    autonomousDatabaseId: "my-instance",
    location: "us-east4",
    project: "my-project",
    database: "mydatabase",
    adminPassword: "123Abpassword",
    network: _default.then(_default => _default.id),
    cidr: "10.5.0.0/24",
    properties: {
        computeCount: 2,
        dataStorageSizeTb: 1,
        dbVersion: "19c",
        dbWorkload: "OLTP",
        licenseType: "LICENSE_INCLUDED",
    },
    deletionProtection: true,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.compute.get_network(name="new",
    project="my-project")
my_adb = gcp.oracledatabase.AutonomousDatabase("myADB",
    autonomous_database_id="my-instance",
    location="us-east4",
    project="my-project",
    database="mydatabase",
    admin_password="123Abpassword",
    network=default.id,
    cidr="10.5.0.0/24",
    properties={
        "compute_count": 2,
        "data_storage_size_tb": 1,
        "db_version": "19c",
        "db_workload": "OLTP",
        "license_type": "LICENSE_INCLUDED",
    },
    deletion_protection=True)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = Gcp.Compute.GetNetwork.Invoke(new()
    {
        Name = "new",
        Project = "my-project",
    });
    var myADB = new Gcp.OracleDatabase.AutonomousDatabase("myADB", new()
    {
        AutonomousDatabaseId = "my-instance",
        Location = "us-east4",
        Project = "my-project",
        Database = "mydatabase",
        AdminPassword = "123Abpassword",
        Network = @default.Apply(@default => @default.Apply(getNetworkResult => getNetworkResult.Id)),
        Cidr = "10.5.0.0/24",
        Properties = new Gcp.OracleDatabase.Inputs.AutonomousDatabasePropertiesArgs
        {
            ComputeCount = 2,
            DataStorageSizeTb = 1,
            DbVersion = "19c",
            DbWorkload = "OLTP",
            LicenseType = "LICENSE_INCLUDED",
        },
        DeletionProtection = true,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/oracledatabase"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
			Name:    "new",
			Project: pulumi.StringRef("my-project"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = oracledatabase.NewAutonomousDatabase(ctx, "myADB", &oracledatabase.AutonomousDatabaseArgs{
			AutonomousDatabaseId: pulumi.String("my-instance"),
			Location:             pulumi.String("us-east4"),
			Project:              pulumi.String("my-project"),
			Database:             pulumi.String("mydatabase"),
			AdminPassword:        pulumi.String("123Abpassword"),
			Network:              pulumi.String(_default.Id),
			Cidr:                 pulumi.String("10.5.0.0/24"),
			Properties: &oracledatabase.AutonomousDatabasePropertiesArgs{
				ComputeCount:      pulumi.Float64(2),
				DataStorageSizeTb: pulumi.Int(1),
				DbVersion:         pulumi.String("19c"),
				DbWorkload:        pulumi.String("OLTP"),
				LicenseType:       pulumi.String("LICENSE_INCLUDED"),
			},
			DeletionProtection: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
import com.pulumi.gcp.oracledatabase.AutonomousDatabase;
import com.pulumi.gcp.oracledatabase.AutonomousDatabaseArgs;
import com.pulumi.gcp.oracledatabase.inputs.AutonomousDatabasePropertiesArgs;
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) {
        final var default = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .name("new")
            .project("my-project")
            .build());
        var myADB = new AutonomousDatabase("myADB", AutonomousDatabaseArgs.builder()
            .autonomousDatabaseId("my-instance")
            .location("us-east4")
            .project("my-project")
            .database("mydatabase")
            .adminPassword("123Abpassword")
            .network(default_.id())
            .cidr("10.5.0.0/24")
            .properties(AutonomousDatabasePropertiesArgs.builder()
                .computeCount(2.0)
                .dataStorageSizeTb(1)
                .dbVersion("19c")
                .dbWorkload("OLTP")
                .licenseType("LICENSE_INCLUDED")
                .build())
            .deletionProtection(true)
            .build());
    }
}
Content copied to clipboard
resources:
  myADB:
    type: gcp:oracledatabase:AutonomousDatabase
    properties:
      autonomousDatabaseId: my-instance
      location: us-east4
      project: my-project
      database: mydatabase
      adminPassword: 123Abpassword
      network: ${default.id}
      cidr: 10.5.0.0/24
      properties:
        computeCount: '2'
        dataStorageSizeTb: '1'
        dbVersion: 19c
        dbWorkload: OLTP
        licenseType: LICENSE_INCLUDED
      deletionProtection: 'true'
variables:
  default:
    fn::invoke:
      function: gcp:compute:getNetwork
      arguments:
        name: new
        project: my-project
Content copied to clipboard

Oracledatabase Autonomous Database Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = gcp.compute.getNetwork({
    name: "new",
    project: "my-project",
});
const myADB = new gcp.oracledatabase.AutonomousDatabase("myADB", {
    autonomousDatabaseId: "my-instance",
    location: "us-east4",
    project: "my-project",
    displayName: "autonomousDatabase displayname",
    database: "mydatabase",
    adminPassword: "123Abpassword",
    network: _default.then(_default => _default.id),
    cidr: "10.5.0.0/24",
    labels: {
        "label-one": "value-one",
    },
    properties: {
        computeCount: 2,
        dataStorageSizeGb: 48,
        dbVersion: "19c",
        dbEdition: "STANDARD_EDITION",
        dbWorkload: "OLTP",
        isAutoScalingEnabled: true,
        licenseType: "BRING_YOUR_OWN_LICENSE",
        backupRetentionPeriodDays: 60,
        characterSet: "AL32UTF8",
        isStorageAutoScalingEnabled: false,
        maintenanceScheduleType: "REGULAR",
        mtlsConnectionRequired: false,
        nCharacterSet: "AL16UTF16",
        operationsInsightsState: "NOT_ENABLED",
        customerContacts: [{
            email: "xyz@example.com",
        }],
        privateEndpointIp: "10.5.0.11",
        privateEndpointLabel: "myendpoint",
    },
    deletionProtection: true,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.compute.get_network(name="new",
    project="my-project")
my_adb = gcp.oracledatabase.AutonomousDatabase("myADB",
    autonomous_database_id="my-instance",
    location="us-east4",
    project="my-project",
    display_name="autonomousDatabase displayname",
    database="mydatabase",
    admin_password="123Abpassword",
    network=default.id,
    cidr="10.5.0.0/24",
    labels={
        "label-one": "value-one",
    },
    properties={
        "compute_count": 2,
        "data_storage_size_gb": 48,
        "db_version": "19c",
        "db_edition": "STANDARD_EDITION",
        "db_workload": "OLTP",
        "is_auto_scaling_enabled": True,
        "license_type": "BRING_YOUR_OWN_LICENSE",
        "backup_retention_period_days": 60,
        "character_set": "AL32UTF8",
        "is_storage_auto_scaling_enabled": False,
        "maintenance_schedule_type": "REGULAR",
        "mtls_connection_required": False,
        "n_character_set": "AL16UTF16",
        "operations_insights_state": "NOT_ENABLED",
        "customer_contacts": [{
            "email": "xyz@example.com",
        }],
        "private_endpoint_ip": "10.5.0.11",
        "private_endpoint_label": "myendpoint",
    },
    deletion_protection=True)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = Gcp.Compute.GetNetwork.Invoke(new()
    {
        Name = "new",
        Project = "my-project",
    });
    var myADB = new Gcp.OracleDatabase.AutonomousDatabase("myADB", new()
    {
        AutonomousDatabaseId = "my-instance",
        Location = "us-east4",
        Project = "my-project",
        DisplayName = "autonomousDatabase displayname",
        Database = "mydatabase",
        AdminPassword = "123Abpassword",
        Network = @default.Apply(@default => @default.Apply(getNetworkResult => getNetworkResult.Id)),
        Cidr = "10.5.0.0/24",
        Labels =
        {
            { "label-one", "value-one" },
        },
        Properties = new Gcp.OracleDatabase.Inputs.AutonomousDatabasePropertiesArgs
        {
            ComputeCount = 2,
            DataStorageSizeGb = 48,
            DbVersion = "19c",
            DbEdition = "STANDARD_EDITION",
            DbWorkload = "OLTP",
            IsAutoScalingEnabled = true,
            LicenseType = "BRING_YOUR_OWN_LICENSE",
            BackupRetentionPeriodDays = 60,
            CharacterSet = "AL32UTF8",
            IsStorageAutoScalingEnabled = false,
            MaintenanceScheduleType = "REGULAR",
            MtlsConnectionRequired = false,
            NCharacterSet = "AL16UTF16",
            OperationsInsightsState = "NOT_ENABLED",
            CustomerContacts = new[]
            {
                new Gcp.OracleDatabase.Inputs.AutonomousDatabasePropertiesCustomerContactArgs
                {
                    Email = "xyz@example.com",
                },
            },
            PrivateEndpointIp = "10.5.0.11",
            PrivateEndpointLabel = "myendpoint",
        },
        DeletionProtection = true,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/oracledatabase"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
			Name:    "new",
			Project: pulumi.StringRef("my-project"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = oracledatabase.NewAutonomousDatabase(ctx, "myADB", &oracledatabase.AutonomousDatabaseArgs{
			AutonomousDatabaseId: pulumi.String("my-instance"),
			Location:             pulumi.String("us-east4"),
			Project:              pulumi.String("my-project"),
			DisplayName:          pulumi.String("autonomousDatabase displayname"),
			Database:             pulumi.String("mydatabase"),
			AdminPassword:        pulumi.String("123Abpassword"),
			Network:              pulumi.String(_default.Id),
			Cidr:                 pulumi.String("10.5.0.0/24"),
			Labels: pulumi.StringMap{
				"label-one": pulumi.String("value-one"),
			},
			Properties: &oracledatabase.AutonomousDatabasePropertiesArgs{
				ComputeCount:                pulumi.Float64(2),
				DataStorageSizeGb:           pulumi.Int(48),
				DbVersion:                   pulumi.String("19c"),
				DbEdition:                   pulumi.String("STANDARD_EDITION"),
				DbWorkload:                  pulumi.String("OLTP"),
				IsAutoScalingEnabled:        pulumi.Bool(true),
				LicenseType:                 pulumi.String("BRING_YOUR_OWN_LICENSE"),
				BackupRetentionPeriodDays:   pulumi.Int(60),
				CharacterSet:                pulumi.String("AL32UTF8"),
				IsStorageAutoScalingEnabled: pulumi.Bool(false),
				MaintenanceScheduleType:     pulumi.String("REGULAR"),
				MtlsConnectionRequired:      pulumi.Bool(false),
				NCharacterSet:               pulumi.String("AL16UTF16"),
				OperationsInsightsState:     pulumi.String("NOT_ENABLED"),
				CustomerContacts: oracledatabase.AutonomousDatabasePropertiesCustomerContactArray{
					&oracledatabase.AutonomousDatabasePropertiesCustomerContactArgs{
						Email: pulumi.String("xyz@example.com"),
					},
				},
				PrivateEndpointIp:    pulumi.String("10.5.0.11"),
				PrivateEndpointLabel: pulumi.String("myendpoint"),
			},
			DeletionProtection: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
import com.pulumi.gcp.oracledatabase.AutonomousDatabase;
import com.pulumi.gcp.oracledatabase.AutonomousDatabaseArgs;
import com.pulumi.gcp.oracledatabase.inputs.AutonomousDatabasePropertiesArgs;
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) {
        final var default = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .name("new")
            .project("my-project")
            .build());
        var myADB = new AutonomousDatabase("myADB", AutonomousDatabaseArgs.builder()
            .autonomousDatabaseId("my-instance")
            .location("us-east4")
            .project("my-project")
            .displayName("autonomousDatabase displayname")
            .database("mydatabase")
            .adminPassword("123Abpassword")
            .network(default_.id())
            .cidr("10.5.0.0/24")
            .labels(Map.of("label-one", "value-one"))
            .properties(AutonomousDatabasePropertiesArgs.builder()
                .computeCount(2.0)
                .dataStorageSizeGb(48)
                .dbVersion("19c")
                .dbEdition("STANDARD_EDITION")
                .dbWorkload("OLTP")
                .isAutoScalingEnabled(true)
                .licenseType("BRING_YOUR_OWN_LICENSE")
                .backupRetentionPeriodDays(60)
                .characterSet("AL32UTF8")
                .isStorageAutoScalingEnabled(false)
                .maintenanceScheduleType("REGULAR")
                .mtlsConnectionRequired(false)
                .nCharacterSet("AL16UTF16")
                .operationsInsightsState("NOT_ENABLED")
                .customerContacts(AutonomousDatabasePropertiesCustomerContactArgs.builder()
                    .email("xyz@example.com")
                    .build())
                .privateEndpointIp("10.5.0.11")
                .privateEndpointLabel("myendpoint")
                .build())
            .deletionProtection(true)
            .build());
    }
}
Content copied to clipboard
resources:
  myADB:
    type: gcp:oracledatabase:AutonomousDatabase
    properties:
      autonomousDatabaseId: my-instance
      location: us-east4
      project: my-project
      displayName: autonomousDatabase displayname
      database: mydatabase
      adminPassword: 123Abpassword
      network: ${default.id}
      cidr: 10.5.0.0/24
      labels:
        label-one: value-one
      properties:
        computeCount: '2'
        dataStorageSizeGb: '48'
        dbVersion: 19c
        dbEdition: STANDARD_EDITION
        dbWorkload: OLTP
        isAutoScalingEnabled: 'true'
        licenseType: BRING_YOUR_OWN_LICENSE
        backupRetentionPeriodDays: '60'
        characterSet: AL32UTF8
        isStorageAutoScalingEnabled: 'false'
        maintenanceScheduleType: REGULAR
        mtlsConnectionRequired: 'false'
        nCharacterSet: AL16UTF16
        operationsInsightsState: NOT_ENABLED
        customerContacts:
          - email: xyz@example.com
        privateEndpointIp: 10.5.0.11
        privateEndpointLabel: myendpoint
      deletionProtection: 'true'
variables:
  default:
    fn::invoke:
      function: gcp:compute:getNetwork
      arguments:
        name: new
        project: my-project
Content copied to clipboard

Import

AutonomousDatabase can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/autonomousDatabases/{{autonomous_database_id}}

  • {{project}}/{{location}}/{{autonomous_database_id}}

  • {{location}}/{{autonomous_database_id}} When using the pulumi import command, AutonomousDatabase can be imported using one of the formats above. For example:

$ pulumi import gcp:oracledatabase/autonomousDatabase:AutonomousDatabase default projects/{{project}}/locations/{{location}}/autonomousDatabases/{{autonomous_database_id}}
Content copied to clipboard
$ pulumi import gcp:oracledatabase/autonomousDatabase:AutonomousDatabase default {{project}}/{{location}}/{{autonomous_database_id}}
Content copied to clipboard
$ pulumi import gcp:oracledatabase/autonomousDatabase:AutonomousDatabase default {{location}}/{{autonomous_database_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val adminPassword: Output<String>?

The password for the default ADMIN user.

Link copied to clipboard
val autonomousDatabaseId: Output<String>

The ID of the Autonomous Database to create. This value is restricted to (^a-z?$) and must be a maximum of 63 characters in length. The value must start with a letter and end with a letter or a number.

Link copied to clipboard
val cidr: Output<String>

The subnet CIDR range for the Autonmous Database.

Link copied to clipboard
val createTime: Output<String>

The date and time that the Autonomous Database was created.

Link copied to clipboard
val database: Output<String>

The name of the Autonomous Database. The database name must be unique in the project. The name must begin with a letter and can contain a maximum of 30 alphanumeric characters.

Link copied to clipboard
val deletionProtection: Output<Boolean>?
Link copied to clipboard
val displayName: Output<String>

The display name for the Autonomous Database. The name does not have to be unique within your project.

Link copied to clipboard
val 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.

Link copied to clipboard
val entitlementId: Output<String>

The ID of the subscription entitlement associated with the Autonomous Database.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

The labels or tags associated with the Autonomous Database. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>

Resource ID segment making up resource name. See documentation for resource type oracledatabase.googleapis.com/AutonomousDatabaseBackup.

Link copied to clipboard
val name: Output<String>

Identifier. The name of the Autonomous Database resource in the following format: projects/{project}/locations/{region}/autonomousDatabases/{autonomous_database}

Link copied to clipboard
val network: Output<String>

The name of the VPC network used by the Autonomous Database. Format: projects/{project}/global/networks/{network}

Link copied to clipboard
val project: Output<String>
Link copied to clipboard
val properties: Output<AutonomousDatabaseProperties>

The properties of an Autonomous Database. Structure is documented below.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val urn: Output<String>