Skip to content
v2.278.0

BackupSelectionOptions Struct ​

Options for a BackupSelection.

Example ​

ts
declare const plan: backup.BackupPlan;
declare const vpc: ec2.Vpc;
const myTable = dynamodb.Table.fromTableName(this, 'Table', 'myTableName');
const myDatabaseInstance = new rds.DatabaseInstance(this, 'DatabaseInstance', {
  engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_26 }),
  vpc,
});
const myDatabaseCluster = new rds.DatabaseCluster(this, 'DatabaseCluster', {
  engine: rds.DatabaseClusterEngine.auroraMysql({ version: rds.AuroraMysqlEngineVersion.VER_2_08_1 }),
  credentials: rds.Credentials.fromGeneratedSecret('clusteradmin'),
  instanceProps: {
    vpc,
  },
});
const myServerlessCluster = new rds.ServerlessCluster(this, 'ServerlessCluster', {
  engine: rds.DatabaseClusterEngine.AURORA_POSTGRESQL,
  parameterGroup: rds.ParameterGroup.fromParameterGroupName(this, 'ParameterGroup', 'default.aurora-postgresql11'),
  vpc,
});
const myCoolConstruct = new Construct(this, 'MyCoolConstruct');

plan.addSelection('Selection', {
  resources: [
    backup.BackupResource.fromDynamoDbTable(myTable), // A DynamoDB table
    backup.BackupResource.fromRdsDatabaseInstance(myDatabaseInstance), // A RDS instance
    backup.BackupResource.fromRdsDatabaseCluster(myDatabaseCluster), // A RDS database cluster
    backup.BackupResource.fromRdsServerlessCluster(myServerlessCluster), // An Aurora Serverless cluster
    backup.BackupResource.fromTag('stage', 'prod'), // All resources that are tagged stage=prod in the region/account
    backup.BackupResource.fromConstruct(myCoolConstruct), // All backupable resources in `myCoolConstruct`
  ]
})
python
# plan: backup.BackupPlan
# vpc: ec2.Vpc

my_table = dynamodb.Table.from_table_name(self, "Table", "myTableName")
my_database_instance = rds.DatabaseInstance(self, "DatabaseInstance",
    engine=rds.DatabaseInstanceEngine.mysql(version=rds.MysqlEngineVersion.VER_8_0_26),
    vpc=vpc
)
my_database_cluster = rds.DatabaseCluster(self, "DatabaseCluster",
    engine=rds.DatabaseClusterEngine.aurora_mysql(version=rds.AuroraMysqlEngineVersion.VER_2_08_1),
    credentials=rds.Credentials.from_generated_secret("clusteradmin"),
    instance_props=rds.InstanceProps(
        vpc=vpc
    )
)
my_serverless_cluster = rds.ServerlessCluster(self, "ServerlessCluster",
    engine=rds.DatabaseClusterEngine.AURORA_POSTGRESQL,
    parameter_group=rds.ParameterGroup.from_parameter_group_name(self, "ParameterGroup", "default.aurora-postgresql11"),
    vpc=vpc
)
my_cool_construct = Construct(self, "MyCoolConstruct")

plan.add_selection("Selection",
    resources=[
        backup.BackupResource.from_dynamo_db_table(my_table),  # A DynamoDB table
        backup.BackupResource.from_rds_database_instance(my_database_instance),  # A RDS instance
        backup.BackupResource.from_rds_database_cluster(my_database_cluster),  # A RDS database cluster
        backup.BackupResource.from_rds_serverless_cluster(my_serverless_cluster),  # An Aurora Serverless cluster
        backup.BackupResource.from_tag("stage", "prod"),  # All resources that are tagged stage=prod in the region/account
        backup.BackupResource.from_construct(my_cool_construct)
    ]
)
java
BackupPlan plan;
Vpc vpc;

ITable myTable = Table.fromTableName(this, "Table", "myTableName");
DatabaseInstance myDatabaseInstance = DatabaseInstance.Builder.create(this, "DatabaseInstance")
        .engine(DatabaseInstanceEngine.mysql(MySqlInstanceEngineProps.builder().version(MysqlEngineVersion.VER_8_0_26).build()))
        .vpc(vpc)
        .build();
DatabaseCluster myDatabaseCluster = DatabaseCluster.Builder.create(this, "DatabaseCluster")
        .engine(DatabaseClusterEngine.auroraMysql(AuroraMysqlClusterEngineProps.builder().version(AuroraMysqlEngineVersion.VER_2_08_1).build()))
        .credentials(Credentials.fromGeneratedSecret("clusteradmin"))
        .instanceProps(InstanceProps.builder()
                .vpc(vpc)
                .build())
        .build();
ServerlessCluster myServerlessCluster = ServerlessCluster.Builder.create(this, "ServerlessCluster")
        .engine(DatabaseClusterEngine.AURORA_POSTGRESQL)
        .parameterGroup(ParameterGroup.fromParameterGroupName(this, "ParameterGroup", "default.aurora-postgresql11"))
        .vpc(vpc)
        .build();
Construct myCoolConstruct = new Construct(this, "MyCoolConstruct");

plan.addSelection("Selection", BackupSelectionOptions.builder()
        .resources(List.of(BackupResource.fromDynamoDbTable(myTable), BackupResource.fromRdsDatabaseInstance(myDatabaseInstance), BackupResource.fromRdsDatabaseCluster(myDatabaseCluster), BackupResource.fromRdsServerlessCluster(myServerlessCluster), BackupResource.fromTag("stage", "prod"), BackupResource.fromConstruct(myCoolConstruct)))
        .build());
csharp
// Install: dotnet add package Amazon.CDK.Lib
BackupPlan plan;
Vpc vpc;

var myTable = Table.FromTableName(this, "Table", "myTableName");
var myDatabaseInstance = new DatabaseInstance(this, "DatabaseInstance", new DatabaseInstanceProps {
    Engine = DatabaseInstanceEngine.Mysql(new MySqlInstanceEngineProps { Version = MysqlEngineVersion.VER_8_0_26 }),
    Vpc = vpc
});
var myDatabaseCluster = new DatabaseCluster(this, "DatabaseCluster", new DatabaseClusterProps {
    Engine = DatabaseClusterEngine.AuroraMysql(new AuroraMysqlClusterEngineProps { Version = AuroraMysqlEngineVersion.VER_2_08_1 }),
    Credentials = Credentials.FromGeneratedSecret("clusteradmin"),
    InstanceProps = new InstanceProps {
        Vpc = vpc
    }
});
var myServerlessCluster = new ServerlessCluster(this, "ServerlessCluster", new ServerlessClusterProps {
    Engine = DatabaseClusterEngine.AURORA_POSTGRESQL,
    ParameterGroup = ParameterGroup.FromParameterGroupName(this, "ParameterGroup", "default.aurora-postgresql11"),
    Vpc = vpc
});
var myCoolConstruct = new Construct(this, "MyCoolConstruct");

plan.AddSelection("Selection", new BackupSelectionOptions {
    Resources = new [] { BackupResource.FromDynamoDbTable(myTable), BackupResource.FromRdsDatabaseInstance(myDatabaseInstance), BackupResource.FromRdsDatabaseCluster(myDatabaseCluster), BackupResource.FromRdsServerlessCluster(myServerlessCluster), BackupResource.FromTag("stage", "prod"), BackupResource.FromConstruct(myCoolConstruct) }
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
var plan BackupPlan
var vpc Vpc

myTable := dynamodb.Table_FromTableName(this, jsii.String("Table"), jsii.String("myTableName"))
myDatabaseInstance := rds.NewDatabaseInstance(this, jsii.String("DatabaseInstance"), &DatabaseInstanceProps{
	Engine: rds.DatabaseInstanceEngine_Mysql(&MySqlInstanceEngineProps{
		Version: rds.MysqlEngineVersion_VER_8_0_26(),
	}),
	Vpc: Vpc,
})
myDatabaseCluster := rds.NewDatabaseCluster(this, jsii.String("DatabaseCluster"), &DatabaseClusterProps{
	Engine: rds.DatabaseClusterEngine_AuroraMysql(&AuroraMysqlClusterEngineProps{
		Version: rds.AuroraMysqlEngineVersion_VER_2_08_1(),
	}),
	Credentials: rds.Credentials_FromGeneratedSecret(jsii.String("clusteradmin")),
	InstanceProps: &InstanceProps{
		Vpc: *Vpc,
	},
})
myServerlessCluster := rds.NewServerlessCluster(this, jsii.String("ServerlessCluster"), &ServerlessClusterProps{
	Engine: rds.DatabaseClusterEngine_AURORA_POSTGRESQL(),
	ParameterGroup: rds.ParameterGroup_FromParameterGroupName(this, jsii.String("ParameterGroup"), jsii.String("default.aurora-postgresql11")),
	Vpc: Vpc,
})
myCoolConstruct := constructs.NewConstruct(this, jsii.String("MyCoolConstruct"))

plan.AddSelection(jsii.String("Selection"), &BackupSelectionOptions{
	Resources: []BackupResource{
		backup.BackupResource_FromDynamoDbTable(myTable),
		backup.BackupResource_FromRdsDatabaseInstance(myDatabaseInstance),
		backup.BackupResource_FromRdsDatabaseCluster(myDatabaseCluster),
		backup.BackupResource_FromRdsServerlessCluster(myServerlessCluster),
		backup.BackupResource_FromTag(jsii.String("stage"), jsii.String("prod")),
		backup.BackupResource_FromConstruct(myCoolConstruct),
	},
})

Properties ​

allowRestoresoptionalbooleanallow_restoresoptionalboolallowRestoresoptionalBooleanAllowRestoresoptionalboolAllowRestoresoptional*bool = false #
Whether to automatically give restores permissions to the role that AWS Backup uses.

If true, the AWSBackupServiceRolePolicyForRestores managed policy will be attached to the role.

backupSelectionNameoptionalstringbackup_selection_nameoptionalstrbackupSelectionNameoptionalStringBackupSelectionNameoptionalstringBackupSelectionNameoptional*string #
The name for this selection.

Default: a CDK generated name

disableDefaultBackupPolicyoptionalbooleandisable_default_backup_policyoptionalbooldisableDefaultBackupPolicyoptionalBooleanDisableDefaultBackupPolicyoptionalboolDisableDefaultBackupPolicyoptional*bool = false #
Whether to disable automatically assigning default backup permissions to the role that AWS Backup uses.

If false, the AWSBackupServiceRolePolicyForBackup managed policy will be attached to the role.

resourcesBackupResource[]resourcestyping.List[BackupResource]resourcesList<BackupResource>ResourcesBackupResource[]Resources*[]BackupResource required #
The resources to backup.

Use the helper static methods defined on BackupResource.

roleoptionalIRoleroleoptionalIRoleroleoptionalIRoleRoleoptionalIRoleRoleoptionalIRole #
The role that AWS Backup uses to authenticate when backuping or restoring the resources.

Default: a new role will be created

The AWSBackupServiceRolePolicyForBackup managed policy will be attached to this role unless disableDefaultBackupPolicy is set to true.