pulumi-alicloud-kotlin/com.pulumi.alicloud.hbr.kotlin/OtsBackupPlan

OtsBackupPlan

class OtsBackupPlan : KotlinCustomResource

Provides a HBR Ots Backup Plan resource. For information about HBR Ots Backup Plan and how to use it, see What is Ots Backup Plan.

NOTE: Available in v1.163.0+.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as random from "@pulumi/random";
const defaultInteger = new random.index.Integer("default", {
    max: 99999,
    min: 10000,
});
const defaultVault = new alicloud.hbr.Vault("default", {
    vaultName: `terraform-example-${defaultInteger.result}`,
    vaultType: "OTS_BACKUP",
});
const defaultInstance = new alicloud.ots.Instance("default", {
    name: `Example-${defaultInteger.result}`,
    description: "terraform-example",
    accessedBy: "Any",
    tags: {
        Created: "TF",
        For: "example",
    },
});
const defaultTable = new alicloud.ots.Table("default", {
    instanceName: defaultInstance.name,
    tableName: "terraform_example",
    primaryKeys: [{
        name: "pk1",
        type: "Integer",
    }],
    timeToLive: -1,
    maxVersion: 1,
    deviationCellVersionInSec: "1",
});
const defaultRole = new alicloud.ram.Role("default", {
    name: "hbrexamplerole",
    document: `\x09\x09{
\x09\x09\x09"Statement": [
\x09\x09\x09{
\x09\x09\x09\x09"Action": "sts:AssumeRole",
\x09\x09\x09\x09"Effect": "Allow",
\x09\x09\x09\x09"Principal": {
\x09\x09\x09\x09\x09"Service": [
\x09\x09\x09\x09\x09\x09"crossbackup.hbr.aliyuncs.com"
\x09\x09\x09\x09\x09]
\x09\x09\x09\x09}
\x09\x09\x09}
\x09\x09\x09],
  \x09\x09\x09"Version": "1"
\x09\x09}
`,
    force: true,
});
const default = alicloud.getAccount({});
const example = new alicloud.hbr.OtsBackupPlan("example", {
    otsBackupPlanName: `terraform-example-${defaultInteger.result}`,
    vaultId: defaultVault.id,
    backupType: "COMPLETE",
    retention: "1",
    instanceName: defaultInstance.name,
    crossAccountType: "SELF_ACCOUNT",
    crossAccountUserId: _default.then(_default => _default.id),
    crossAccountRoleName: defaultRole.id,
    otsDetails: [{
        tableNames: [defaultTable&#46;tableName],
    }],
    rules: [{
        schedule: "I|1602673264|PT2H",
        retention: "1",
        disabled: false,
        ruleName: "terraform-example",
        backupType: "COMPLETE",
    }],
});

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random
default_integer = random.index.Integer("default",
    max=99999,
    min=10000)
default_vault = alicloud.hbr.Vault("default",
    vault_name=f"terraform-example-{default_integer['result']}",
    vault_type="OTS_BACKUP")
default_instance = alicloud.ots.Instance("default",
    name=f"Example-{default_integer['result']}",
    description="terraform-example",
    accessed_by="Any",
    tags={
        "Created": "TF",
        "For": "example",
    })
default_table = alicloud.ots.Table("default",
    instance_name=default_instance.name,
    table_name="terraform_example",
    primary_keys=[alicloud.ots.TablePrimaryKeyArgs(
        name="pk1",
        type="Integer",
    )],
    time_to_live=-1,
    max_version=1,
    deviation_cell_version_in_sec="1")
default_role = alicloud.ram.Role("default",
    name="hbrexamplerole",
    document="""\x09\x09{
\x09\x09\x09"Statement": [
\x09\x09\x09{
\x09\x09\x09\x09"Action": "sts:AssumeRole",
\x09\x09\x09\x09"Effect": "Allow",
\x09\x09\x09\x09"Principal": {
\x09\x09\x09\x09\x09"Service": [
\x09\x09\x09\x09\x09\x09"crossbackup.hbr.aliyuncs.com"
\x09\x09\x09\x09\x09]
\x09\x09\x09\x09}
\x09\x09\x09}
\x09\x09\x09],
  \x09\x09\x09"Version": "1"
\x09\x09}
""",
    force=True)
default = alicloud.get_account()
example = alicloud.hbr.OtsBackupPlan("example",
    ots_backup_plan_name=f"terraform-example-{default_integer['result']}",
    vault_id=default_vault.id,
    backup_type="COMPLETE",
    retention="1",
    instance_name=default_instance.name,
    cross_account_type="SELF_ACCOUNT",
    cross_account_user_id=default.id,
    cross_account_role_name=default_role.id,
    ots_details=[alicloud.hbr.OtsBackupPlanOtsDetailArgs(
        table_names=[default_table&#46;table_name],
    )],
    rules=[alicloud.hbr.OtsBackupPlanRuleArgs(
        schedule="I|1602673264|PT2H",
        retention="1",
        disabled=False,
        rule_name="terraform-example",
        backup_type="COMPLETE",
    )])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;
return await Deployment.RunAsync(() =>
{
    var defaultInteger = new Random.Index.Integer("default", new()
    {
        Max = 99999,
        Min = 10000,
    });
    var defaultVault = new AliCloud.Hbr.Vault("default", new()
    {
        VaultName = $"terraform-example-{defaultInteger.Result}",
        VaultType = "OTS_BACKUP",
    });
    var defaultInstance = new AliCloud.Ots.Instance("default", new()
    {
        Name = $"Example-{defaultInteger.Result}",
        Description = "terraform-example",
        AccessedBy = "Any",
        Tags =
        {
            { "Created", "TF" },
            { "For", "example" },
        },
    });
    var defaultTable = new AliCloud.Ots.Table("default", new()
    {
        InstanceName = defaultInstance.Name,
        TableName = "terraform_example",
        PrimaryKeys = new[]
        {
            new AliCloud.Ots.Inputs.TablePrimaryKeyArgs
            {
                Name = "pk1",
                Type = "Integer",
            },
        },
        TimeToLive = -1,
        MaxVersion = 1,
        DeviationCellVersionInSec = "1",
    });
    var defaultRole = new AliCloud.Ram.Role("default", new()
    {
        Name = "hbrexamplerole",
        Document = @"		{
			""Statement"": [
			{
				""Action"": ""sts:AssumeRole"",
				""Effect"": ""Allow"",
				""Principal"": {
					""Service"": [
						""crossbackup.hbr.aliyuncs.com""
					]
				}
			}
			],
  			""Version"": ""1""
		}
",
        Force = true,
    });
    var @default = AliCloud.GetAccount.Invoke();
    var example = new AliCloud.Hbr.OtsBackupPlan("example", new()
    {
        OtsBackupPlanName = $"terraform-example-{defaultInteger.Result}",
        VaultId = defaultVault.Id,
        BackupType = "COMPLETE",
        Retention = "1",
        InstanceName = defaultInstance.Name,
        CrossAccountType = "SELF_ACCOUNT",
        CrossAccountUserId = @default.Apply(@default => @default.Apply(getAccountResult => getAccountResult.Id)),
        CrossAccountRoleName = defaultRole.Id,
        OtsDetails = new[]
        {
            new AliCloud.Hbr.Inputs.OtsBackupPlanOtsDetailArgs
            {
                TableNames = new[]
                {
                    defaultTable.TableName,
                },
            },
        },
        Rules = new[]
        {
            new AliCloud.Hbr.Inputs.OtsBackupPlanRuleArgs
            {
                Schedule = "I|1602673264|PT2H",
                Retention = "1",
                Disabled = false,
                RuleName = "terraform-example",
                BackupType = "COMPLETE",
            },
        },
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/hbr"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ots"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ram"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultInteger, err := random.NewInteger(ctx, "default", &random.IntegerArgs{
			Max: 99999,
			Min: 10000,
		})
		if err != nil {
			return err
		}
		defaultVault, err := hbr.NewVault(ctx, "default", &hbr.VaultArgs{
			VaultName: pulumi.String(fmt.Sprintf("terraform-example-%v", defaultInteger.Result)),
			VaultType: pulumi.String("OTS_BACKUP"),
		})
		if err != nil {
			return err
		}
		defaultInstance, err := ots.NewInstance(ctx, "default", &ots.InstanceArgs{
			Name:        pulumi.String(fmt.Sprintf("Example-%v", defaultInteger.Result)),
			Description: pulumi.String("terraform-example"),
			AccessedBy:  pulumi.String("Any"),
			Tags: pulumi.Map{
				"Created": pulumi.Any("TF"),
				"For":     pulumi.Any("example"),
			},
		})
		if err != nil {
			return err
		}
		defaultTable, err := ots.NewTable(ctx, "default", &ots.TableArgs{
			InstanceName: defaultInstance.Name,
			TableName:    pulumi.String("terraform_example"),
			PrimaryKeys: ots.TablePrimaryKeyArray{
				&ots.TablePrimaryKeyArgs{
					Name: pulumi.String("pk1"),
					Type: pulumi.String("Integer"),
				},
			},
			TimeToLive:                -1,
			MaxVersion:                pulumi.Int(1),
			DeviationCellVersionInSec: pulumi.String("1"),
		})
		if err != nil {
			return err
		}
		defaultRole, err := ram.NewRole(ctx, "default", &ram.RoleArgs{
			Name: pulumi.String("hbrexamplerole"),
			Document: pulumi.String(`		{
			"Statement": [
			{
				"Action": "sts:AssumeRole",
				"Effect": "Allow",
				"Principal": {
					"Service": [
						"crossbackup.hbr.aliyuncs.com"
					]
				}
			}
			],
  			"Version": "1"
		}
`),
			Force: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_default, err := alicloud.GetAccount(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = hbr.NewOtsBackupPlan(ctx, "example", &hbr.OtsBackupPlanArgs{
			OtsBackupPlanName:    pulumi.String(fmt.Sprintf("terraform-example-%v", defaultInteger.Result)),
			VaultId:              defaultVault.ID(),
			BackupType:           pulumi.String("COMPLETE"),
			Retention:            pulumi.String("1"),
			InstanceName:         defaultInstance.Name,
			CrossAccountType:     pulumi.String("SELF_ACCOUNT"),
			CrossAccountUserId:   pulumi.String(_default.Id),
			CrossAccountRoleName: defaultRole.ID(),
			OtsDetails: hbr.OtsBackupPlanOtsDetailArray{
				&hbr.OtsBackupPlanOtsDetailArgs{
					TableNames: pulumi.StringArray{
						defaultTable.TableName,
					},
				},
			},
			Rules: hbr.OtsBackupPlanRuleArray{
				&hbr.OtsBackupPlanRuleArgs{
					Schedule:   pulumi.String("I|1602673264|PT2H"),
					Retention:  pulumi.String("1"),
					Disabled:   pulumi.Bool(false),
					RuleName:   pulumi.String("terraform-example"),
					BackupType: pulumi.String("COMPLETE"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

Import

HBR Ots Backup Plan can be imported using the id, e.g.

$ pulumi import alicloud:hbr/otsBackupPlan:OtsBackupPlan example <id>

Properties

backupType

val backupType: Output<String>

Backup type. Valid values: COMPLETE.

crossAccountRoleName

val crossAccountRoleName: Output<String>?

The role name created in the original account RAM backup by the cross account managed by the current account.

crossAccountType

val crossAccountType: Output<String>

The type of the cross account backup. Valid values: SELF_ACCOUNT, CROSS_ACCOUNT.

crossAccountUserId

val crossAccountUserId: Output<Int>?

The original account ID of the cross account backup managed by the current account.

disabled

val disabled: Output<Boolean>

Whether to disable the backup task. Valid values: true, false. Default values: false.

val id: Output<String>

instanceName

val instanceName: Output<String>?

The name of the Table store instance. Note: Required while source_type equals OTS_TABLE.

otsBackupPlanName

val otsBackupPlanName: Output<String>

The name of the backup plan. 1~64 characters, the backup plan name of each data source type in a single warehouse required to be unique.

otsDetails

val otsDetails: Output<List<OtsBackupPlanOtsDetail>>?

The details about the Table store instance. See the following Block ots_detail. Note: Required while source_type equals OTS_TABLE.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

retention

val retention: Output<String>

Backup retention days, the minimum is 1.

rules

val rules: Output<List<OtsBackupPlanRule>>?

The backup plan rule. See the following Block rules. Note: Required while source_type equals OTS_TABLE.

schedule

val ~~schedule~~: Output<String>?

Backup strategy. Optional format: I|{startTime}|{interval}. It means to execute a backup task every {interval} starting from {startTime}. The backup task for the elapsed time will not be compensated. If the last backup task has not completed yet, the next backup task will not be triggered.

urn

val urn: Output<String>

vaultId

val vaultId: Output<String>?

The ID of backup vault.