alicloud.dbs.BackupPlan

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default = alicloud.resourcemanager.get_resource_groups(status="OK")
default_get_zones = alicloud.rds.get_zones(engine="MySQL",
    engine_version="8.0",
    instance_charge_type="PostPaid",
    category="HighAvailability",
    db_instance_storage_type="cloud_essd")
default_get_instance_classes = alicloud.rds.get_instance_classes(zone_id=default_get_zones.zones[1].id,
    engine="MySQL",
    engine_version="8.0",
    category="HighAvailability",
    db_instance_storage_type="cloud_essd",
    instance_charge_type="PostPaid")
default_get_networks = alicloud.vpc.get_networks(name_regex="^default-NODELETING")
default_get_switches = alicloud.vpc.get_switches(vpc_id=default_get_networks.ids[0],
    zone_id=default_get_zones.zones[1].id)
vswitch_id = default_get_switches.ids[0]
zone_id = default_get_zones.ids[1]
default_security_group = alicloud.ecs.SecurityGroup("default",
    name=name,
    vpc_id=default_get_networks.ids[0])
default_instance = alicloud.rds.Instance("default",
    engine="MySQL",
    engine_version="8.0",
    db_instance_storage_type="cloud_essd",
    instance_type=default_get_instance_classes.instance_classes[0].instance_class,
    instance_storage=default_get_instance_classes.instance_classes[0].storage_range.min,
    vswitch_id=vswitch_id,
    instance_name=name)
default_database = alicloud.rds.Database("default",
    instance_id=default_instance.id,
    name="tfdatabase")
default_rds_account = alicloud.rds.RdsAccount("default",
    db_instance_id=default_instance.id,
    account_name="tfnormal000",
    account_password="Test12345")
default_account_privilege = alicloud.rds.AccountPrivilege("default",
    instance_id=default_instance.id,
    account_name=default_rds_account.account_name,
    privilege="ReadWrite",
    db_names=[default_database.name])
default_backup_plan = alicloud.dbs.BackupPlan("default",
    backup_plan_name=name,
    payment_type="PayAsYouGo",
    instance_class="xlarge",
    backup_method="logical",
    database_type="MySQL",
    database_region="cn-hangzhou",
    storage_region="cn-hangzhou",
    instance_type="RDS",
    source_endpoint_instance_type="RDS",
    resource_group_id=default.ids[0],
    source_endpoint_region="cn-hangzhou",
    source_endpoint_instance_id=default_instance.id,
    source_endpoint_user_name=default_account_privilege.account_name,
    source_endpoint_password=default_rds_account.account_password,
    backup_objects=default_database.name.apply(lambda name: f"[{{\"DBName\":\"{name}\"}}]"),
    backup_period="Monday",
    backup_start_time="14:22",
    backup_storage_type="system",
    backup_retention_period=740)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/dbs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/rds"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/resourcemanager"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := resourcemanager.GetResourceGroups(ctx, &resourcemanager.GetResourceGroupsArgs{
			Status: pulumi.StringRef("OK"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetZones, err := rds.GetZones(ctx, &rds.GetZonesArgs{
			Engine:                pulumi.StringRef("MySQL"),
			EngineVersion:         pulumi.StringRef("8.0"),
			InstanceChargeType:    pulumi.StringRef("PostPaid"),
			Category:              pulumi.StringRef("HighAvailability"),
			DbInstanceStorageType: pulumi.StringRef("cloud_essd"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetInstanceClasses, err := rds.GetInstanceClasses(ctx, &rds.GetInstanceClassesArgs{
			ZoneId:                pulumi.StringRef(defaultGetZones.Zones[1].Id),
			Engine:                pulumi.StringRef("MySQL"),
			EngineVersion:         pulumi.StringRef("8.0"),
			Category:              pulumi.StringRef("HighAvailability"),
			DbInstanceStorageType: pulumi.StringRef("cloud_essd"),
			InstanceChargeType:    pulumi.StringRef("PostPaid"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetNetworks, err := vpc.GetNetworks(ctx, &vpc.GetNetworksArgs{
			NameRegex: pulumi.StringRef("^default-NODELETING"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetSwitches, err := vpc.GetSwitches(ctx, &vpc.GetSwitchesArgs{
			VpcId:  pulumi.StringRef(defaultGetNetworks.Ids[0]),
			ZoneId: pulumi.StringRef(defaultGetZones.Zones[1].Id),
		}, nil)
		if err != nil {
			return err
		}
		vswitchId := defaultGetSwitches.Ids[0]
		_ := defaultGetZones.Ids[1]
		_, err = ecs.NewSecurityGroup(ctx, "default", &ecs.SecurityGroupArgs{
			Name:  pulumi.String(name),
			VpcId: pulumi.String(defaultGetNetworks.Ids[0]),
		})
		if err != nil {
			return err
		}
		defaultInstance, err := rds.NewInstance(ctx, "default", &rds.InstanceArgs{
			Engine:                pulumi.String("MySQL"),
			EngineVersion:         pulumi.String("8.0"),
			DbInstanceStorageType: pulumi.String("cloud_essd"),
			InstanceType:          pulumi.String(defaultGetInstanceClasses.InstanceClasses[0].InstanceClass),
			InstanceStorage:       pulumi.String(defaultGetInstanceClasses.InstanceClasses[0].StorageRange.Min),
			VswitchId:             pulumi.String(vswitchId),
			InstanceName:          pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultDatabase, err := rds.NewDatabase(ctx, "default", &rds.DatabaseArgs{
			InstanceId: defaultInstance.ID(),
			Name:       pulumi.String("tfdatabase"),
		})
		if err != nil {
			return err
		}
		defaultRdsAccount, err := rds.NewRdsAccount(ctx, "default", &rds.RdsAccountArgs{
			DbInstanceId:    defaultInstance.ID(),
			AccountName:     pulumi.String("tfnormal000"),
			AccountPassword: pulumi.String("Test12345"),
		})
		if err != nil {
			return err
		}
		defaultAccountPrivilege, err := rds.NewAccountPrivilege(ctx, "default", &rds.AccountPrivilegeArgs{
			InstanceId:  defaultInstance.ID(),
			AccountName: defaultRdsAccount.AccountName,
			Privilege:   pulumi.String("ReadWrite"),
			DbNames: pulumi.StringArray{
				defaultDatabase.Name,
			},
		})
		if err != nil {
			return err
		}
		_, err = dbs.NewBackupPlan(ctx, "default", &dbs.BackupPlanArgs{
			BackupPlanName:             pulumi.String(name),
			PaymentType:                pulumi.String("PayAsYouGo"),
			InstanceClass:              pulumi.String("xlarge"),
			BackupMethod:               pulumi.String("logical"),
			DatabaseType:               pulumi.String("MySQL"),
			DatabaseRegion:             pulumi.String("cn-hangzhou"),
			StorageRegion:              pulumi.String("cn-hangzhou"),
			InstanceType:               pulumi.String("RDS"),
			SourceEndpointInstanceType: pulumi.String("RDS"),
			ResourceGroupId:            pulumi.String(_default.Ids[0]),
			SourceEndpointRegion:       pulumi.String("cn-hangzhou"),
			SourceEndpointInstanceId:   defaultInstance.ID(),
			SourceEndpointUserName:     defaultAccountPrivilege.AccountName,
			SourceEndpointPassword:     defaultRdsAccount.AccountPassword,
			BackupObjects: defaultDatabase.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("[{\"DBName\":\"%v\"}]", name), nil
			}).(pulumi.StringOutput),
			BackupPeriod:          pulumi.String("Monday"),
			BackupStartTime:       pulumi.String("14:22"),
			BackupStorageType:     pulumi.String("system"),
			BackupRetentionPeriod: pulumi.Int(740),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var @default = AliCloud.ResourceManager.GetResourceGroups.Invoke(new()
    {
        Status = "OK",
    });

    var defaultGetZones = AliCloud.Rds.GetZones.Invoke(new()
    {
        Engine = "MySQL",
        EngineVersion = "8.0",
        InstanceChargeType = "PostPaid",
        Category = "HighAvailability",
        DbInstanceStorageType = "cloud_essd",
    });

    var defaultGetInstanceClasses = AliCloud.Rds.GetInstanceClasses.Invoke(new()
    {
        ZoneId = defaultGetZones.Apply(getZonesResult => getZonesResult.Zones[1]?.Id),
        Engine = "MySQL",
        EngineVersion = "8.0",
        Category = "HighAvailability",
        DbInstanceStorageType = "cloud_essd",
        InstanceChargeType = "PostPaid",
    });

    var defaultGetNetworks = AliCloud.Vpc.GetNetworks.Invoke(new()
    {
        NameRegex = "^default-NODELETING",
    });

    var defaultGetSwitches = AliCloud.Vpc.GetSwitches.Invoke(new()
    {
        VpcId = defaultGetNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
        ZoneId = defaultGetZones.Apply(getZonesResult => getZonesResult.Zones[1]?.Id),
    });

    var vswitchId = defaultGetSwitches.Apply(getSwitchesResult => getSwitchesResult.Ids[0]);

    var zoneId = defaultGetZones.Apply(getZonesResult => getZonesResult.Ids[1]);

    var defaultSecurityGroup = new AliCloud.Ecs.SecurityGroup("default", new()
    {
        Name = name,
        VpcId = defaultGetNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
    });

    var defaultInstance = new AliCloud.Rds.Instance("default", new()
    {
        Engine = "MySQL",
        EngineVersion = "8.0",
        DbInstanceStorageType = "cloud_essd",
        InstanceType = defaultGetInstanceClasses.Apply(getInstanceClassesResult => getInstanceClassesResult.InstanceClasses[0]?.InstanceClass),
        InstanceStorage = defaultGetInstanceClasses.Apply(getInstanceClassesResult => getInstanceClassesResult.InstanceClasses[0]?.StorageRange?.Min),
        VswitchId = vswitchId,
        InstanceName = name,
    });

    var defaultDatabase = new AliCloud.Rds.Database("default", new()
    {
        InstanceId = defaultInstance.Id,
        Name = "tfdatabase",
    });

    var defaultRdsAccount = new AliCloud.Rds.RdsAccount("default", new()
    {
        DbInstanceId = defaultInstance.Id,
        AccountName = "tfnormal000",
        AccountPassword = "Test12345",
    });

    var defaultAccountPrivilege = new AliCloud.Rds.AccountPrivilege("default", new()
    {
        InstanceId = defaultInstance.Id,
        AccountName = defaultRdsAccount.AccountName,
        Privilege = "ReadWrite",
        DbNames = new[]
        {
            defaultDatabase.Name,
        },
    });

    var defaultBackupPlan = new AliCloud.DBS.BackupPlan("default", new()
    {
        BackupPlanName = name,
        PaymentType = "PayAsYouGo",
        InstanceClass = "xlarge",
        BackupMethod = "logical",
        DatabaseType = "MySQL",
        DatabaseRegion = "cn-hangzhou",
        StorageRegion = "cn-hangzhou",
        InstanceType = "RDS",
        SourceEndpointInstanceType = "RDS",
        ResourceGroupId = @default.Apply(@default => @default.Apply(getResourceGroupsResult => getResourceGroupsResult.Ids[0])),
        SourceEndpointRegion = "cn-hangzhou",
        SourceEndpointInstanceId = defaultInstance.Id,
        SourceEndpointUserName = defaultAccountPrivilege.AccountName,
        SourceEndpointPassword = defaultRdsAccount.AccountPassword,
        BackupObjects = defaultDatabase.Name.Apply(name => $"[{{\"DBName\":\"{name}\"}}]"),
        BackupPeriod = "Monday",
        BackupStartTime = "14:22",
        BackupStorageType = "system",
        BackupRetentionPeriod = 740,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.resourcemanager.ResourcemanagerFunctions;
import com.pulumi.alicloud.resourcemanager.inputs.GetResourceGroupsArgs;
import com.pulumi.alicloud.rds.RdsFunctions;
import com.pulumi.alicloud.rds.inputs.GetZonesArgs;
import com.pulumi.alicloud.rds.inputs.GetInstanceClassesArgs;
import com.pulumi.alicloud.vpc.VpcFunctions;
import com.pulumi.alicloud.vpc.inputs.GetNetworksArgs;
import com.pulumi.alicloud.vpc.inputs.GetSwitchesArgs;
import com.pulumi.alicloud.ecs.SecurityGroup;
import com.pulumi.alicloud.ecs.SecurityGroupArgs;
import com.pulumi.alicloud.rds.Instance;
import com.pulumi.alicloud.rds.InstanceArgs;
import com.pulumi.alicloud.rds.Database;
import com.pulumi.alicloud.rds.DatabaseArgs;
import com.pulumi.alicloud.rds.RdsAccount;
import com.pulumi.alicloud.rds.RdsAccountArgs;
import com.pulumi.alicloud.rds.AccountPrivilege;
import com.pulumi.alicloud.rds.AccountPrivilegeArgs;
import com.pulumi.alicloud.dbs.BackupPlan;
import com.pulumi.alicloud.dbs.BackupPlanArgs;
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 config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        final var default = ResourcemanagerFunctions.getResourceGroups(GetResourceGroupsArgs.builder()
            .status("OK")
            .build());

        final var defaultGetZones = RdsFunctions.getZones(GetZonesArgs.builder()
            .engine("MySQL")
            .engineVersion("8.0")
            .instanceChargeType("PostPaid")
            .category("HighAvailability")
            .dbInstanceStorageType("cloud_essd")
            .build());

        final var defaultGetInstanceClasses = RdsFunctions.getInstanceClasses(GetInstanceClassesArgs.builder()
            .zoneId(defaultGetZones.applyValue(getZonesResult -> getZonesResult.zones()[1].id()))
            .engine("MySQL")
            .engineVersion("8.0")
            .category("HighAvailability")
            .dbInstanceStorageType("cloud_essd")
            .instanceChargeType("PostPaid")
            .build());

        final var defaultGetNetworks = VpcFunctions.getNetworks(GetNetworksArgs.builder()
            .nameRegex("^default-NODELETING")
            .build());

        final var defaultGetSwitches = VpcFunctions.getSwitches(GetSwitchesArgs.builder()
            .vpcId(defaultGetNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .zoneId(defaultGetZones.applyValue(getZonesResult -> getZonesResult.zones()[1].id()))
            .build());

        final var vswitchId = defaultGetSwitches.applyValue(getSwitchesResult -> getSwitchesResult.ids()[0]);

        final var zoneId = defaultGetZones.applyValue(getZonesResult -> getZonesResult.ids()[1]);

        var defaultSecurityGroup = new SecurityGroup("defaultSecurityGroup", SecurityGroupArgs.builder()
            .name(name)
            .vpcId(defaultGetNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .build());

        var defaultInstance = new Instance("defaultInstance", InstanceArgs.builder()
            .engine("MySQL")
            .engineVersion("8.0")
            .dbInstanceStorageType("cloud_essd")
            .instanceType(defaultGetInstanceClasses.applyValue(getInstanceClassesResult -> getInstanceClassesResult.instanceClasses()[0].instanceClass()))
            .instanceStorage(defaultGetInstanceClasses.applyValue(getInstanceClassesResult -> getInstanceClassesResult.instanceClasses()[0].storageRange().min()))
            .vswitchId(vswitchId)
            .instanceName(name)
            .build());

        var defaultDatabase = new Database("defaultDatabase", DatabaseArgs.builder()
            .instanceId(defaultInstance.id())
            .name("tfdatabase")
            .build());

        var defaultRdsAccount = new RdsAccount("defaultRdsAccount", RdsAccountArgs.builder()
            .dbInstanceId(defaultInstance.id())
            .accountName("tfnormal000")
            .accountPassword("Test12345")
            .build());

        var defaultAccountPrivilege = new AccountPrivilege("defaultAccountPrivilege", AccountPrivilegeArgs.builder()
            .instanceId(defaultInstance.id())
            .accountName(defaultRdsAccount.accountName())
            .privilege("ReadWrite")
            .dbNames(defaultDatabase.name())
            .build());

        var defaultBackupPlan = new BackupPlan("defaultBackupPlan", BackupPlanArgs.builder()
            .backupPlanName(name)
            .paymentType("PayAsYouGo")
            .instanceClass("xlarge")
            .backupMethod("logical")
            .databaseType("MySQL")
            .databaseRegion("cn-hangzhou")
            .storageRegion("cn-hangzhou")
            .instanceType("RDS")
            .sourceEndpointInstanceType("RDS")
            .resourceGroupId(default_.ids()[0])
            .sourceEndpointRegion("cn-hangzhou")
            .sourceEndpointInstanceId(defaultInstance.id())
            .sourceEndpointUserName(defaultAccountPrivilege.accountName())
            .sourceEndpointPassword(defaultRdsAccount.accountPassword())
            .backupObjects(defaultDatabase.name().applyValue(name -> String.format("[{{\"DBName\":\"%s\"}}]", name)))
            .backupPeriod("Monday")
            .backupStartTime("14:22")
            .backupStorageType("system")
            .backupRetentionPeriod(740)
            .build());

    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    name: default
    properties:
      name: ${name}
      vpcId: ${defaultGetNetworks.ids[0]}
  defaultInstance:
    type: alicloud:rds:Instance
    name: default
    properties:
      engine: MySQL
      engineVersion: '8.0'
      dbInstanceStorageType: cloud_essd
      instanceType: ${defaultGetInstanceClasses.instanceClasses[0].instanceClass}
      instanceStorage: ${defaultGetInstanceClasses.instanceClasses[0].storageRange.min}
      vswitchId: ${vswitchId}
      instanceName: ${name}
  defaultDatabase:
    type: alicloud:rds:Database
    name: default
    properties:
      instanceId: ${defaultInstance.id}
      name: tfdatabase
  defaultRdsAccount:
    type: alicloud:rds:RdsAccount
    name: default
    properties:
      dbInstanceId: ${defaultInstance.id}
      accountName: tfnormal000
      accountPassword: Test12345
  defaultAccountPrivilege:
    type: alicloud:rds:AccountPrivilege
    name: default
    properties:
      instanceId: ${defaultInstance.id}
      accountName: ${defaultRdsAccount.accountName}
      privilege: ReadWrite
      dbNames:
        - ${defaultDatabase.name}
  defaultBackupPlan:
    type: alicloud:dbs:BackupPlan
    name: default
    properties:
      backupPlanName: ${name}
      paymentType: PayAsYouGo
      instanceClass: xlarge
      backupMethod: logical
      databaseType: MySQL
      databaseRegion: cn-hangzhou
      storageRegion: cn-hangzhou
      instanceType: RDS
      sourceEndpointInstanceType: RDS
      resourceGroupId: ${default.ids[0]}
      sourceEndpointRegion: cn-hangzhou
      sourceEndpointInstanceId: ${defaultInstance.id}
      sourceEndpointUserName: ${defaultAccountPrivilege.accountName}
      sourceEndpointPassword: ${defaultRdsAccount.accountPassword}
      backupObjects: '[{"DBName":"${defaultDatabase.name}"}]'
      backupPeriod: Monday
      backupStartTime: 14:22
      backupStorageType: system
      backupRetentionPeriod: 740
variables:
  default:
    fn::invoke:
      function: alicloud:resourcemanager:getResourceGroups
      arguments:
        status: OK
  defaultGetZones:
    fn::invoke:
      function: alicloud:rds:getZones
      arguments:
        engine: MySQL
        engineVersion: '8.0'
        instanceChargeType: PostPaid
        category: HighAvailability
        dbInstanceStorageType: cloud_essd
  defaultGetInstanceClasses:
    fn::invoke:
      function: alicloud:rds:getInstanceClasses
      arguments:
        zoneId: ${defaultGetZones.zones[1].id}
        engine: MySQL
        engineVersion: '8.0'
        category: HighAvailability
        dbInstanceStorageType: cloud_essd
        instanceChargeType: PostPaid
  defaultGetNetworks:
    fn::invoke:
      function: alicloud:vpc:getNetworks
      arguments:
        nameRegex: ^default-NODELETING
  defaultGetSwitches:
    fn::invoke:
      function: alicloud:vpc:getSwitches
      arguments:
        vpcId: ${defaultGetNetworks.ids[0]}
        zoneId: ${defaultGetZones.zones[1].id}
  vswitchId: ${defaultGetSwitches.ids[0]}
  zoneId: ${defaultGetZones.ids[1]}

var alicloudBackupPlanResource = new AliCloud.DBS.BackupPlan("alicloudBackupPlanResource", new()
{
    BackupPlanName = "string",
    SourceEndpointInstanceType = "string",
    BackupMethod = "string",
    InstanceClass = "string",
    DatabaseType = "string",
    BackupStartTime = "string",
    PaymentType = "string",
    BackupRetentionPeriod = 0,
    BackupSpeedLimit = "string",
    BackupGatewayId = "string",
    BackupStorageType = "string",
    BackupStrategyType = "string",
    CrossAliyunId = "string",
    CrossRoleName = "string",
    DatabaseRegion = "string",
    BackupPeriod = "string",
    DuplicationArchivePeriod = 0,
    DuplicationInfrequentAccessPeriod = 0,
    EnableBackupLog = false,
    BackupObjects = "string",
    InstanceType = "string",
    OssBucketName = "string",
    BackupRateLimit = "string",
    Period = "string",
    ResourceGroupId = "string",
    SourceEndpointDatabaseName = "string",
    SourceEndpointInstanceId = "string",
    BackupLogIntervalSeconds = 0,
    SourceEndpointIp = "string",
    SourceEndpointOracleSid = "string",
    SourceEndpointPassword = "string",
    SourceEndpointPort = 0,
    SourceEndpointRegion = "string",
    SourceEndpointSid = "string",
    SourceEndpointUserName = "string",
    Status = "string",
    StorageRegion = "string",
    UsedTime = 0,
});

example, err := dbs.NewBackupPlan(ctx, "alicloudBackupPlanResource", &dbs.BackupPlanArgs{
	BackupPlanName:                    pulumi.String("string"),
	SourceEndpointInstanceType:        pulumi.String("string"),
	BackupMethod:                      pulumi.String("string"),
	InstanceClass:                     pulumi.String("string"),
	DatabaseType:                      pulumi.String("string"),
	BackupStartTime:                   pulumi.String("string"),
	PaymentType:                       pulumi.String("string"),
	BackupRetentionPeriod:             pulumi.Int(0),
	BackupSpeedLimit:                  pulumi.String("string"),
	BackupGatewayId:                   pulumi.String("string"),
	BackupStorageType:                 pulumi.String("string"),
	BackupStrategyType:                pulumi.String("string"),
	CrossAliyunId:                     pulumi.String("string"),
	CrossRoleName:                     pulumi.String("string"),
	DatabaseRegion:                    pulumi.String("string"),
	BackupPeriod:                      pulumi.String("string"),
	DuplicationArchivePeriod:          pulumi.Int(0),
	DuplicationInfrequentAccessPeriod: pulumi.Int(0),
	EnableBackupLog:                   pulumi.Bool(false),
	BackupObjects:                     pulumi.String("string"),
	InstanceType:                      pulumi.String("string"),
	OssBucketName:                     pulumi.String("string"),
	BackupRateLimit:                   pulumi.String("string"),
	Period:                            pulumi.String("string"),
	ResourceGroupId:                   pulumi.String("string"),
	SourceEndpointDatabaseName:        pulumi.String("string"),
	SourceEndpointInstanceId:          pulumi.String("string"),
	BackupLogIntervalSeconds:          pulumi.Int(0),
	SourceEndpointIp:                  pulumi.String("string"),
	SourceEndpointOracleSid:           pulumi.String("string"),
	SourceEndpointPassword:            pulumi.String("string"),
	SourceEndpointPort:                pulumi.Int(0),
	SourceEndpointRegion:              pulumi.String("string"),
	SourceEndpointSid:                 pulumi.String("string"),
	SourceEndpointUserName:            pulumi.String("string"),
	Status:                            pulumi.String("string"),
	StorageRegion:                     pulumi.String("string"),
	UsedTime:                          pulumi.Int(0),
})

var alicloudBackupPlanResource = new BackupPlan("alicloudBackupPlanResource", BackupPlanArgs.builder()
    .backupPlanName("string")
    .sourceEndpointInstanceType("string")
    .backupMethod("string")
    .instanceClass("string")
    .databaseType("string")
    .backupStartTime("string")
    .paymentType("string")
    .backupRetentionPeriod(0)
    .backupSpeedLimit("string")
    .backupGatewayId("string")
    .backupStorageType("string")
    .backupStrategyType("string")
    .crossAliyunId("string")
    .crossRoleName("string")
    .databaseRegion("string")
    .backupPeriod("string")
    .duplicationArchivePeriod(0)
    .duplicationInfrequentAccessPeriod(0)
    .enableBackupLog(false)
    .backupObjects("string")
    .instanceType("string")
    .ossBucketName("string")
    .backupRateLimit("string")
    .period("string")
    .resourceGroupId("string")
    .sourceEndpointDatabaseName("string")
    .sourceEndpointInstanceId("string")
    .backupLogIntervalSeconds(0)
    .sourceEndpointIp("string")
    .sourceEndpointOracleSid("string")
    .sourceEndpointPassword("string")
    .sourceEndpointPort(0)
    .sourceEndpointRegion("string")
    .sourceEndpointSid("string")
    .sourceEndpointUserName("string")
    .status("string")
    .storageRegion("string")
    .usedTime(0)
    .build());

alicloud_backup_plan_resource = alicloud.dbs.BackupPlan("alicloudBackupPlanResource",
    backup_plan_name="string",
    source_endpoint_instance_type="string",
    backup_method="string",
    instance_class="string",
    database_type="string",
    backup_start_time="string",
    payment_type="string",
    backup_retention_period=0,
    backup_speed_limit="string",
    backup_gateway_id="string",
    backup_storage_type="string",
    backup_strategy_type="string",
    cross_aliyun_id="string",
    cross_role_name="string",
    database_region="string",
    backup_period="string",
    duplication_archive_period=0,
    duplication_infrequent_access_period=0,
    enable_backup_log=False,
    backup_objects="string",
    instance_type="string",
    oss_bucket_name="string",
    backup_rate_limit="string",
    period="string",
    resource_group_id="string",
    source_endpoint_database_name="string",
    source_endpoint_instance_id="string",
    backup_log_interval_seconds=0,
    source_endpoint_ip="string",
    source_endpoint_oracle_sid="string",
    source_endpoint_password="string",
    source_endpoint_port=0,
    source_endpoint_region="string",
    source_endpoint_sid="string",
    source_endpoint_user_name="string",
    status="string",
    storage_region="string",
    used_time=0)

type: alicloud:dbs:BackupPlan
properties:
    backupGatewayId: string
    backupLogIntervalSeconds: 0
    backupMethod: string
    backupObjects: string
    backupPeriod: string
    backupPlanName: string
    backupRateLimit: string
    backupRetentionPeriod: 0
    backupSpeedLimit: string
    backupStartTime: string
    backupStorageType: string
    backupStrategyType: string
    crossAliyunId: string
    crossRoleName: string
    databaseRegion: string
    databaseType: string
    duplicationArchivePeriod: 0
    duplicationInfrequentAccessPeriod: 0
    enableBackupLog: false
    instanceClass: string
    instanceType: string
    ossBucketName: string
    paymentType: string
    period: string
    resourceGroupId: string
    sourceEndpointDatabaseName: string
    sourceEndpointInstanceId: string
    sourceEndpointInstanceType: string
    sourceEndpointIp: string
    sourceEndpointOracleSid: string
    sourceEndpointPassword: string
    sourceEndpointPort: 0
    sourceEndpointRegion: string
    sourceEndpointSid: string
    sourceEndpointUserName: string
    status: string
    storageRegion: string
    usedTime: 0