alicloud.dbs.BackupPlan

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const defaultResourceGroups = alicloud.resourcemanager.getResourceGroups({
    status: "OK",
});
const defaultZones = alicloud.rds.getZones({
    engine: "MySQL",
    engineVersion: "8.0",
    instanceChargeType: "PostPaid",
    category: "HighAvailability",
    dbInstanceStorageType: "cloud_essd",
});
const defaultInstanceClasses = defaultZones.then(defaultZones => alicloud.rds.getInstanceClasses({
    zoneId: defaultZones.zones?.[0]?.id,
    engine: "MySQL",
    engineVersion: "8.0",
    category: "HighAvailability",
    dbInstanceStorageType: "cloud_essd",
    instanceChargeType: "PostPaid",
}));
const defaultNetworks = alicloud.vpc.getNetworks({
    nameRegex: "^default-NODELETING",
});
const defaultSwitches = Promise.all([defaultNetworks, defaultZones]).then(([defaultNetworks, defaultZones]) => alicloud.vpc.getSwitches({
    vpcId: defaultNetworks.ids?.[0],
    zoneId: defaultZones.zones?.[0]?.id,
}));
const vswitchId = defaultSwitches.then(defaultSwitches => defaultSwitches.ids?.[0]);
const zoneId = defaultZones.then(defaultZones => defaultZones.ids?.[0]);
const defaultSecurityGroup = new alicloud.ecs.SecurityGroup("defaultSecurityGroup", {vpcId: defaultNetworks.then(defaultNetworks => defaultNetworks.ids?.[0])});
const defaultInstance = new alicloud.rds.Instance("defaultInstance", {
    engine: "MySQL",
    engineVersion: "8.0",
    dbInstanceStorageType: "cloud_essd",
    instanceType: defaultInstanceClasses.then(defaultInstanceClasses => defaultInstanceClasses.instanceClasses?.[0]?.instanceClass),
    instanceStorage: defaultInstanceClasses.then(defaultInstanceClasses => defaultInstanceClasses.instanceClasses?.[0]?.storageRange?.min),
    vswitchId: vswitchId,
    instanceName: name,
});
const defaultDatabase = new alicloud.rds.Database("defaultDatabase", {instanceId: defaultInstance.id});
const defaultRdsAccount = new alicloud.rds.RdsAccount("defaultRdsAccount", {
    dbInstanceId: defaultInstance.id,
    accountName: "tfnormal000",
    accountPassword: "Test12345",
});
const defaultAccountPrivilege = new alicloud.rds.AccountPrivilege("defaultAccountPrivilege", {
    instanceId: defaultInstance.id,
    accountName: defaultRdsAccount.accountName,
    privilege: "ReadWrite",
    dbNames: [defaultDatabase.name],
});
const defaultBackupPlan = new alicloud.dbs.BackupPlan("defaultBackupPlan", {
    backupPlanName: name,
    paymentType: "PayAsYouGo",
    instanceClass: "xlarge",
    backupMethod: "logical",
    databaseType: "MySQL",
    databaseRegion: "cn-hangzhou",
    storageRegion: "cn-hangzhou",
    instanceType: "RDS",
    sourceEndpointInstanceType: "RDS",
    resourceGroupId: defaultResourceGroups.then(defaultResourceGroups => defaultResourceGroups.ids?.[0]),
    sourceEndpointRegion: "cn-hangzhou",
    sourceEndpointInstanceId: defaultInstance.id,
    sourceEndpointUserName: defaultAccountPrivilege.accountName,
    sourceEndpointPassword: defaultRdsAccount.accountPassword,
    backupObjects: pulumi.interpolate`[{"DBName":"${defaultDatabase.name}"}]`,
    backupPeriod: "Monday",
    backupStartTime: "14:22",
    backupStorageType: "system",
    backupRetentionPeriod: 740,
});

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_resource_groups = alicloud.resourcemanager.get_resource_groups(status="OK")
default_zones = alicloud.rds.get_zones(engine="MySQL",
    engine_version="8.0",
    instance_charge_type="PostPaid",
    category="HighAvailability",
    db_instance_storage_type="cloud_essd")
default_instance_classes = alicloud.rds.get_instance_classes(zone_id=default_zones.zones[0].id,
    engine="MySQL",
    engine_version="8.0",
    category="HighAvailability",
    db_instance_storage_type="cloud_essd",
    instance_charge_type="PostPaid")
default_networks = alicloud.vpc.get_networks(name_regex="^default-NODELETING")
default_switches = alicloud.vpc.get_switches(vpc_id=default_networks.ids[0],
    zone_id=default_zones.zones[0].id)
vswitch_id = default_switches.ids[0]
zone_id = default_zones.ids[0]
default_security_group = alicloud.ecs.SecurityGroup("defaultSecurityGroup", vpc_id=default_networks.ids[0])
default_instance = alicloud.rds.Instance("defaultInstance",
    engine="MySQL",
    engine_version="8.0",
    db_instance_storage_type="cloud_essd",
    instance_type=default_instance_classes.instance_classes[0].instance_class,
    instance_storage=default_instance_classes.instance_classes[0].storage_range.min,
    vswitch_id=vswitch_id,
    instance_name=name)
default_database = alicloud.rds.Database("defaultDatabase", instance_id=default_instance.id)
default_rds_account = alicloud.rds.RdsAccount("defaultRdsAccount",
    db_instance_id=default_instance.id,
    account_name="tfnormal000",
    account_password="Test12345")
default_account_privilege = alicloud.rds.AccountPrivilege("defaultAccountPrivilege",
    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("defaultBackupPlan",
    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_resource_groups.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
		}
		defaultResourceGroups, err := resourcemanager.GetResourceGroups(ctx, &resourcemanager.GetResourceGroupsArgs{
			Status: pulumi.StringRef("OK"),
		}, nil)
		if err != nil {
			return err
		}
		defaultZones, 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
		}
		defaultInstanceClasses, err := rds.GetInstanceClasses(ctx, &rds.GetInstanceClassesArgs{
			ZoneId:                pulumi.StringRef(defaultZones.Zones[0].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
		}
		defaultNetworks, err := vpc.GetNetworks(ctx, &vpc.GetNetworksArgs{
			NameRegex: pulumi.StringRef("^default-NODELETING"),
		}, nil)
		if err != nil {
			return err
		}
		defaultSwitches, err := vpc.GetSwitches(ctx, &vpc.GetSwitchesArgs{
			VpcId:  pulumi.StringRef(defaultNetworks.Ids[0]),
			ZoneId: pulumi.StringRef(defaultZones.Zones[0].Id),
		}, nil)
		if err != nil {
			return err
		}
		vswitchId := defaultSwitches.Ids[0]
		_ := defaultZones.Ids[0]
		_, err = ecs.NewSecurityGroup(ctx, "defaultSecurityGroup", &ecs.SecurityGroupArgs{
			VpcId: pulumi.String(defaultNetworks.Ids[0]),
		})
		if err != nil {
			return err
		}
		defaultInstance, err := rds.NewInstance(ctx, "defaultInstance", &rds.InstanceArgs{
			Engine:                pulumi.String("MySQL"),
			EngineVersion:         pulumi.String("8.0"),
			DbInstanceStorageType: pulumi.String("cloud_essd"),
			InstanceType:          pulumi.String(defaultInstanceClasses.InstanceClasses[0].InstanceClass),
			InstanceStorage:       pulumi.String(defaultInstanceClasses.InstanceClasses[0].StorageRange.Min),
			VswitchId:             pulumi.String(vswitchId),
			InstanceName:          pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultDatabase, err := rds.NewDatabase(ctx, "defaultDatabase", &rds.DatabaseArgs{
			InstanceId: defaultInstance.ID(),
		})
		if err != nil {
			return err
		}
		defaultRdsAccount, err := rds.NewRdsAccount(ctx, "defaultRdsAccount", &rds.RdsAccountArgs{
			DbInstanceId:    defaultInstance.ID(),
			AccountName:     pulumi.String("tfnormal000"),
			AccountPassword: pulumi.String("Test12345"),
		})
		if err != nil {
			return err
		}
		defaultAccountPrivilege, err := rds.NewAccountPrivilege(ctx, "defaultAccountPrivilege", &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, "defaultBackupPlan", &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(defaultResourceGroups.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 defaultResourceGroups = AliCloud.ResourceManager.GetResourceGroups.Invoke(new()
    {
        Status = "OK",
    });

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

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

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

    var defaultSwitches = AliCloud.Vpc.GetSwitches.Invoke(new()
    {
        VpcId = defaultNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
        ZoneId = defaultZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
    });

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

    var zoneId = defaultZones.Apply(getZonesResult => getZonesResult.Ids[0]);

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

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

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

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

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

    var defaultBackupPlan = new AliCloud.DBS.BackupPlan("defaultBackupPlan", new()
    {
        BackupPlanName = name,
        PaymentType = "PayAsYouGo",
        InstanceClass = "xlarge",
        BackupMethod = "logical",
        DatabaseType = "MySQL",
        DatabaseRegion = "cn-hangzhou",
        StorageRegion = "cn-hangzhou",
        InstanceType = "RDS",
        SourceEndpointInstanceType = "RDS",
        ResourceGroupId = defaultResourceGroups.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 defaultResourceGroups = ResourcemanagerFunctions.getResourceGroups(GetResourceGroupsArgs.builder()
            .status("OK")
            .build());

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

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

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

        final var defaultSwitches = VpcFunctions.getSwitches(GetSwitchesArgs.builder()
            .vpcId(defaultNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .zoneId(defaultZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .build());

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

        final var zoneId = defaultZones.applyValue(getZonesResult -> getZonesResult.ids()[0]);

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

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

        var defaultDatabase = new Database("defaultDatabase", DatabaseArgs.builder()        
            .instanceId(defaultInstance.id())
            .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(defaultResourceGroups.applyValue(getResourceGroupsResult -> getResourceGroupsResult.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
    properties:
      vpcId: ${defaultNetworks.ids[0]}
  defaultInstance:
    type: alicloud:rds:Instance
    properties:
      engine: MySQL
      engineVersion: '8.0'
      dbInstanceStorageType: cloud_essd
      instanceType: ${defaultInstanceClasses.instanceClasses[0].instanceClass}
      instanceStorage: ${defaultInstanceClasses.instanceClasses[0].storageRange.min}
      vswitchId: ${vswitchId}
      instanceName: ${name}
  defaultDatabase:
    type: alicloud:rds:Database
    properties:
      instanceId: ${defaultInstance.id}
  defaultRdsAccount:
    type: alicloud:rds:RdsAccount
    properties:
      dbInstanceId: ${defaultInstance.id}
      accountName: tfnormal000
      accountPassword: Test12345
  defaultAccountPrivilege:
    type: alicloud:rds:AccountPrivilege
    properties:
      instanceId: ${defaultInstance.id}
      accountName: ${defaultRdsAccount.accountName}
      privilege: ReadWrite
      dbNames:
        - ${defaultDatabase.name}
  defaultBackupPlan:
    type: alicloud:dbs:BackupPlan
    properties:
      backupPlanName: ${name}
      paymentType: PayAsYouGo
      instanceClass: xlarge
      backupMethod: logical
      databaseType: MySQL
      databaseRegion: cn-hangzhou
      storageRegion: cn-hangzhou
      instanceType: RDS
      sourceEndpointInstanceType: RDS
      resourceGroupId: ${defaultResourceGroups.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:
  defaultResourceGroups:
    fn::invoke:
      Function: alicloud:resourcemanager:getResourceGroups
      Arguments:
        status: OK
  defaultZones:
    fn::invoke:
      Function: alicloud:rds:getZones
      Arguments:
        engine: MySQL
        engineVersion: '8.0'
        instanceChargeType: PostPaid
        category: HighAvailability
        dbInstanceStorageType: cloud_essd
  defaultInstanceClasses:
    fn::invoke:
      Function: alicloud:rds:getInstanceClasses
      Arguments:
        zoneId: ${defaultZones.zones[0].id}
        engine: MySQL
        engineVersion: '8.0'
        category: HighAvailability
        dbInstanceStorageType: cloud_essd
        instanceChargeType: PostPaid
  defaultNetworks:
    fn::invoke:
      Function: alicloud:vpc:getNetworks
      Arguments:
        nameRegex: ^default-NODELETING
  defaultSwitches:
    fn::invoke:
      Function: alicloud:vpc:getSwitches
      Arguments:
        vpcId: ${defaultNetworks.ids[0]}
        zoneId: ${defaultZones.zones[0].id}
  vswitchId: ${defaultSwitches.ids[0]}
  zoneId: ${defaultZones.ids[0]}

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)

const alicloudBackupPlanResource = new alicloud.dbs.BackupPlan("alicloudBackupPlanResource", {
    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,
});

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