ServerlessCluster L2 construct
Create an Aurora Serverless v1 Cluster.
Example
ts
// Create username and password secret for DB Cluster
const secret = new rds.DatabaseSecret(this, 'AuroraSecret', {
username: 'clusteradmin',
});
// The VPC to place the cluster in
const vpc = new ec2.Vpc(this, 'AuroraVpc');
// Create the serverless cluster, provide all values needed to customise the database.
const cluster = new rds.ServerlessCluster(this, 'AuroraCluster', {
engine: rds.DatabaseClusterEngine.AURORA_MYSQL,
vpc,
credentials: { username: 'clusteradmin' },
clusterIdentifier: 'db-endpoint-test',
defaultDatabaseName: 'demos',
});
// Build a data source for AppSync to access the database.
declare const api: appsync.GraphqlApi;
const rdsDS = api.addRdsDataSource('rds', cluster, secret, 'demos');
// Set up a resolver for an RDS query.
rdsDS.createResolver('QueryGetDemosRdsResolver', {
typeName: 'Query',
fieldName: 'getDemosRds',
requestMappingTemplate: appsync.MappingTemplate.fromString(`
{
"version": "2018-05-29",
"statements": [
"SELECT * FROM demos"
]
}
`),
responseMappingTemplate: appsync.MappingTemplate.fromString(`
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0])
`),
});
// Set up a resolver for an RDS mutation.
rdsDS.createResolver('MutationAddDemoRdsResolver', {
typeName: 'Mutation',
fieldName: 'addDemoRds',
requestMappingTemplate: appsync.MappingTemplate.fromString(`
{
"version": "2018-05-29",
"statements": [
"INSERT INTO demos VALUES (:id, :version)",
"SELECT * WHERE id = :id"
],
"variableMap": {
":id": $util.toJson($util.autoId()),
":version": $util.toJson($ctx.args.version)
}
}
`),
responseMappingTemplate: appsync.MappingTemplate.fromString(`
$utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])
`),
});
python
# Build a data source for AppSync to access the database.
# api: appsync.GraphqlApi
# Create username and password secret for DB Cluster
secret = rds.DatabaseSecret(self, "AuroraSecret",
username="clusteradmin"
)
# The VPC to place the cluster in
vpc = ec2.Vpc(self, "AuroraVpc")
# Create the serverless cluster, provide all values needed to customise the database.
cluster = rds.ServerlessCluster(self, "AuroraCluster",
engine=rds.DatabaseClusterEngine.AURORA_MYSQL,
vpc=vpc,
credentials={"username": "clusteradmin"},
cluster_identifier="db-endpoint-test",
default_database_name="demos"
)
rds_ds = api.add_rds_data_source("rds", cluster, secret, "demos")
# Set up a resolver for an RDS query.
rds_ds.create_resolver("QueryGetDemosRdsResolver",
type_name="Query",
field_name="getDemosRds",
request_mapping_template=appsync.MappingTemplate.from_string("""
{
"version": "2018-05-29",
"statements": [
"SELECT * FROM demos"
]
}
"""),
response_mapping_template=appsync.MappingTemplate.from_string("""
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0])
""")
)
# Set up a resolver for an RDS mutation.
rds_ds.create_resolver("MutationAddDemoRdsResolver",
type_name="Mutation",
field_name="addDemoRds",
request_mapping_template=appsync.MappingTemplate.from_string("""
{
"version": "2018-05-29",
"statements": [
"INSERT INTO demos VALUES (:id, :version)",
"SELECT * WHERE id = :id"
],
"variableMap": {
":id": $util.toJson($util.autoId()),
":version": $util.toJson($ctx.args.version)
}
}
"""),
response_mapping_template=appsync.MappingTemplate.from_string("""
$utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])
""")
)
java
// Build a data source for AppSync to access the database.
GraphqlApi api;
// Create username and password secret for DB Cluster
DatabaseSecret secret = DatabaseSecret.Builder.create(this, "AuroraSecret")
.username("clusteradmin")
.build();
// The VPC to place the cluster in
Vpc vpc = new Vpc(this, "AuroraVpc");
// Create the serverless cluster, provide all values needed to customise the database.
ServerlessCluster cluster = ServerlessCluster.Builder.create(this, "AuroraCluster")
.engine(DatabaseClusterEngine.AURORA_MYSQL)
.vpc(vpc)
.credentials(Map.of("username", "clusteradmin"))
.clusterIdentifier("db-endpoint-test")
.defaultDatabaseName("demos")
.build();
RdsDataSource rdsDS = api.addRdsDataSource("rds", cluster, secret, "demos");
// Set up a resolver for an RDS query.
rdsDS.createResolver("QueryGetDemosRdsResolver", BaseResolverProps.builder()
.typeName("Query")
.fieldName("getDemosRds")
.requestMappingTemplate(MappingTemplate.fromString("\n {\n \"version\": \"2018-05-29\",\n \"statements\": [\n \"SELECT * FROM demos\"\n ]\n }\n "))
.responseMappingTemplate(MappingTemplate.fromString("\n $utils.toJson($utils.rds.toJsonObject($ctx.result)[0])\n "))
.build());
// Set up a resolver for an RDS mutation.
rdsDS.createResolver("MutationAddDemoRdsResolver", BaseResolverProps.builder()
.typeName("Mutation")
.fieldName("addDemoRds")
.requestMappingTemplate(MappingTemplate.fromString("\n {\n \"version\": \"2018-05-29\",\n \"statements\": [\n \"INSERT INTO demos VALUES (:id, :version)\",\n \"SELECT * WHERE id = :id\"\n ],\n \"variableMap\": {\n \":id\": $util.toJson($util.autoId()),\n \":version\": $util.toJson($ctx.args.version)\n }\n }\n "))
.responseMappingTemplate(MappingTemplate.fromString("\n $utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])\n "))
.build());
csharp
// Install: dotnet add package Amazon.CDK.Lib
// Build a data source for AppSync to access the database.
GraphqlApi api;
// Create username and password secret for DB Cluster
var secret = new DatabaseSecret(this, "AuroraSecret", new DatabaseSecretProps {
Username = "clusteradmin"
});
// The VPC to place the cluster in
var vpc = new Vpc(this, "AuroraVpc");
// Create the serverless cluster, provide all values needed to customise the database.
var cluster = new ServerlessCluster(this, "AuroraCluster", new ServerlessClusterProps {
Engine = DatabaseClusterEngine.AURORA_MYSQL,
Vpc = vpc,
Credentials = new Dictionary<string, string> { { "username", "clusteradmin" } },
ClusterIdentifier = "db-endpoint-test",
DefaultDatabaseName = "demos"
});
var rdsDS = api.AddRdsDataSource("rds", cluster, secret, "demos");
// Set up a resolver for an RDS query.
rdsDS.CreateResolver("QueryGetDemosRdsResolver", new BaseResolverProps {
TypeName = "Query",
FieldName = "getDemosRds",
RequestMappingTemplate = MappingTemplate.FromString(@"
{
""version"": ""2018-05-29"",
""statements"": [
""SELECT * FROM demos""
]
}
"),
ResponseMappingTemplate = MappingTemplate.FromString(@"
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0])
")
});
// Set up a resolver for an RDS mutation.
rdsDS.CreateResolver("MutationAddDemoRdsResolver", new BaseResolverProps {
TypeName = "Mutation",
FieldName = "addDemoRds",
RequestMappingTemplate = MappingTemplate.FromString(@"
{
""version"": ""2018-05-29"",
""statements"": [
""INSERT INTO demos VALUES (:id, :version)"",
""SELECT * WHERE id = :id""
],
""variableMap"": {
"":id"": $util.toJson($util.autoId()),
"":version"": $util.toJson($ctx.args.version)
}
}
"),
ResponseMappingTemplate = MappingTemplate.FromString(@"
$utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])
")
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// Build a data source for AppSync to access the database.
var api GraphqlApi
// Create username and password secret for DB Cluster
secret := rds.NewDatabaseSecret(this, jsii.String("AuroraSecret"), &DatabaseSecretProps{
Username: jsii.String("clusteradmin"),
})
// The VPC to place the cluster in
vpc := ec2.NewVpc(this, jsii.String("AuroraVpc"))
// Create the serverless cluster, provide all values needed to customise the database.
cluster := rds.NewServerlessCluster(this, jsii.String("AuroraCluster"), &ServerlessClusterProps{
Engine: rds.DatabaseClusterEngine_AURORA_MYSQL(),
Vpc: Vpc,
Credentials: map[string]*string{
"username": jsii.String("clusteradmin"),
},
ClusterIdentifier: jsii.String("db-endpoint-test"),
DefaultDatabaseName: jsii.String("demos"),
})
rdsDS := api.AddRdsDataSource(jsii.String("rds"), cluster, secret, jsii.String("demos"))
// Set up a resolver for an RDS query.
rdsDS.CreateResolver(jsii.String("QueryGetDemosRdsResolver"), &BaseResolverProps{
TypeName: jsii.String("Query"),
FieldName: jsii.String("getDemosRds"),
RequestMappingTemplate: appsync.MappingTemplate_FromString(jsii.String(`
{
"version": "2018-05-29",
"statements": [
"SELECT * FROM demos"
]
}
`)),
ResponseMappingTemplate: appsync.MappingTemplate_*FromString(jsii.String(`
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0])
`)),
})
// Set up a resolver for an RDS mutation.
rdsDS.CreateResolver(jsii.String("MutationAddDemoRdsResolver"), &BaseResolverProps{
TypeName: jsii.String("Mutation"),
FieldName: jsii.String("addDemoRds"),
RequestMappingTemplate: appsync.MappingTemplate_*FromString(jsii.String(`
{
"version": "2018-05-29",
"statements": [
"INSERT INTO demos VALUES (:id, :version)",
"SELECT * WHERE id = :id"
],
"variableMap": {
":id": $util.toJson($util.autoId()),
":version": $util.toJson($ctx.args.version)
}
}
`)),
ResponseMappingTemplate: appsync.MappingTemplate_*FromString(jsii.String(`
$utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])
`)),
})
Initializer
ts
new ServerlessCluster(scope: Construct, id: string, props: ServerlessClusterProps)
python
ServerlessCluster(scope: Construct, id: str, props: ServerlessClusterProps)
java
new ServerlessCluster(Construct scope, String id, ServerlessClusterProps props)
csharp
new ServerlessCluster(Construct scope, string id, ServerlessClusterProps props)
go
NewServerlessCluster(Scope Construct, Id *string, Props ServerlessClusterProps)
Construct Props
backupRetentionoptionalDurationbackup_retentionoptionalDurationbackupRetentionoptionalDurationBackupRetentionoptionalDurationBackupRetentionoptionalDuration= Duration.days(1)#The number of days during which automatic DB snapshots are retained.
Automatic backup retention cannot be disabled on serverless clusters. Must be a value from 1 day to 35 days.
clusterIdentifieroptionalstringcluster_identifieroptionalstrclusterIdentifieroptionalStringClusterIdentifieroptionalstringClusterIdentifieroptional*string#An optional identifier for the cluster.
Default: A name is automatically generated.
copyTagsToSnapshotoptionalbooleancopy_tags_to_snapshotoptionalboolcopyTagsToSnapshotoptionalBooleanCopyTagsToSnapshotoptionalboolCopyTagsToSnapshotoptional*bool= true#Whether to copy tags to the snapshot when a snapshot is created.
credentialsoptionalCredentialscredentialsoptionalCredentialscredentialsoptionalCredentialsCredentialsoptionalCredentialsCredentialsoptionalCredentials#Credentials for the administrative user.
Default: A username of 'admin' and SecretsManager-generated password
defaultDatabaseNameoptionalstringdefault_database_nameoptionalstrdefaultDatabaseNameoptionalStringDefaultDatabaseNameoptionalstringDefaultDatabaseNameoptional*string#Name of a database which is automatically created inside the cluster.
Default: Database is not created in cluster.
deletionProtectionoptionalbooleandeletion_protectionoptionalbooldeletionProtectionoptionalBooleanDeletionProtectionoptionalboolDeletionProtectionoptional*bool#Indicates whether the DB cluster should have deletion protection enabled.
Default: true if removalPolicy is RETAIN, false otherwise
enableDataApioptionalbooleanenable_data_apioptionalboolenableDataApioptionalBooleanEnableDataApioptionalboolEnableDataApioptional*bool= false#Whether to enable the Data API.
engineIClusterEngineengineIClusterEngineengineIClusterEngineEngineIClusterEngineEngineIClusterEnginerequired#What kind of database to start.
parameterGroupoptionalIParameterGroupparameter_groupoptionalIParameterGroupparameterGroupoptionalIParameterGroupParameterGroupoptionalIParameterGroupParameterGroupoptionalIParameterGroup#Additional parameters to pass to the database engine.
Default: no parameter group.
removalPolicyoptionalRemovalPolicyremoval_policyoptionalRemovalPolicyremovalPolicyoptionalRemovalPolicyRemovalPolicyoptionalRemovalPolicyRemovalPolicyoptionalRemovalPolicy#The removal policy to apply when the cluster and its instances are removed from the stack or replaced during an update.
Default: RemovalPolicy.SNAPSHOT (remove the cluster and instances, but retain a snapshot of the data)
scalingoptionalServerlessScalingOptionsscalingoptionalServerlessScalingOptionsscalingoptionalServerlessScalingOptionsScalingoptionalServerlessScalingOptionsScalingoptionalServerlessScalingOptions#Scaling configuration of an Aurora Serverless database cluster.
Default: Serverless cluster is automatically paused after 5 minutes of being idle. minimum capacity: 2 ACU maximum capacity: 16 ACU
securityGroupsoptionalISecurityGroup[]security_groupsoptionaltyping.List[ISecurityGroup]securityGroupsoptionalList<ISecurityGroup>SecurityGroupsoptionalISecurityGroup[]SecurityGroupsoptional*[]ISecurityGroup#Security group.
Default: a new security group is created if vpc was provided. If the vpc property was not provided, no VPC security groups will be associated with the DB cluster.
storageEncryptionKeyoptionalIKeystorage_encryption_keyoptionalIKeystorageEncryptionKeyoptionalIKeyStorageEncryptionKeyoptionalIKeyStorageEncryptionKeyoptionalIKey#The KMS key for storage encryption.
Default: the default master key will be used for storage encryption
subnetGroupoptionalIDBSubnetGroupRefsubnet_groupoptionalIDBSubnetGroupRefsubnetGroupoptionalIDBSubnetGroupRefSubnetGroupoptionalIDBSubnetGroupRefSubnetGroupoptionalIDBSubnetGroupRef#Existing subnet group for the cluster.
Default: a new subnet group is created if vpc was provided. If the vpc property was not provided, no subnet group will be associated with the DB cluster
The VPC that this Aurora Serverless v1 Cluster has been created in.
Default: the default VPC in the account and region will be used
vpcSubnetsoptionalSubnetSelectionvpc_subnetsoptionalSubnetSelectionvpcSubnetsoptionalSubnetSelectionVpcSubnetsoptionalSubnetSelectionVpcSubnetsoptionalSubnetSelection#Where to place the instances within the VPC.
Default: the VPC default strategy if not specified.
If provided, the vpc property must also be specified.
Properties
The ARN of the cluster.
clusterEndpointEndpointcluster_endpointEndpointclusterEndpointEndpointClusterEndpointEndpointClusterEndpointEndpoint#The endpoint to use for read/write operations.
clusterIdentifierstringcluster_identifierstrclusterIdentifierStringClusterIdentifierstringClusterIdentifier*string#Identifier of the cluster.
clusterReadEndpointEndpointcluster_read_endpointEndpointclusterReadEndpointEndpointClusterReadEndpointEndpointClusterReadEndpointEndpoint#The endpoint to use for read/write operations.
connectionsConnectionsconnectionsConnectionsconnectionsConnectionsConnectionsConnectionsConnectionsConnections#Access to the network connections.
dbClusterRefDBClusterReferencedb_cluster_refDBClusterReferencedbClusterRefDBClusterReferenceDbClusterRefDBClusterReferenceDbClusterRefDBClusterReference#A reference to this serverless cluster.
envResourceEnvironmentenvResourceEnvironmentenvResourceEnvironmentEnvResourceEnvironmentEnvResourceEnvironment#The environment this resource belongs to.
notes
For resources that are created and managed in a Stack (those created by creating new class instances like new Role(), new Bucket(), etc.), this is always the same as the environment of the stack they belong to.
For referenced resources (those obtained from referencing methods like Role.fromRoleArn(), Bucket.fromBucketName(), etc.), they might be different than the stack they were imported into.
PROPERTY_INJECTION_IDstringproperty_injection_idstrPROPERTY_INJECTION_IDStringPROPERTY_INJECTION_IDstringPROPERTY_INJECTION_ID*stringstatic#Uniquely identifies this class.
Methods
addRotationMultiUser(id: string, options: RotationMultiUserOptions): SecretRotationdef add_rotation_multi_user(self, id: str, options: RotationMultiUserOptions) -> SecretRotationpublic SecretRotation addRotationMultiUser(String id, RotationMultiUserOptions options)public SecretRotation AddRotationMultiUser(string id, RotationMultiUserOptions options)func AddRotationMultiUser(Id *string, Options RotationMultiUserOptions) SecretRotation#Adds the multi user rotation to this cluster.
addRotationSingleUser(options?: RotationSingleUserOptions): SecretRotationdef add_rotation_single_user(self, options: typing.Optional[RotationSingleUserOptions] = None) -> SecretRotationpublic SecretRotation addRotationSingleUser(RotationSingleUserOptions options)public SecretRotation AddRotationSingleUser(RotationSingleUserOptions? options = null)func AddRotationSingleUser(Options RotationSingleUserOptions) SecretRotation#Adds the single user rotation of the master password to this cluster.
applyCrossStackReferenceStrength(strength: ReferenceStrength): voiddef apply_cross_stack_reference_strength(self, strength: ReferenceStrength) -> Nonepublic void applyCrossStackReferenceStrength(ReferenceStrength strength)public void ApplyCrossStackReferenceStrength(ReferenceStrength strength)func ApplyCrossStackReferenceStrength(Strength ReferenceStrength)#Override the cross-stack reference strength for this resource.
notes · 1 parameter
When set, any cross-stack reference to this resource will use the specified mechanism instead of the global default determined by the @aws-cdk/core:defaultCrossStackReferences context key. This is useful for selectively weakening specific references to avoid the "deadly embrace" problem without changing the app-wide default.
Parameters
strengthstrengthstrengthstrengthStrength— - The reference strength to use for this resource.
applyRemovalPolicy(policy: RemovalPolicy): voiddef apply_removal_policy(self, policy: RemovalPolicy) -> Nonepublic void applyRemovalPolicy(RemovalPolicy policy)public void ApplyRemovalPolicy(RemovalPolicy policy)func ApplyRemovalPolicy(Policy RemovalPolicy)#Apply the given removal policy to this resource.
notes
The Removal Policy controls what happens to this resource when it stops being managed by CloudFormation, either because you've removed it from the CDK application or because you've made a change that requires the resource to be replaced.
The resource can be deleted (RemovalPolicy.DESTROY), or left in your AWS account for data recovery and cleanup later (RemovalPolicy.RETAIN).
asSecretAttachmentTarget(): SecretAttachmentTargetPropsdef as_secret_attachment_target(self, ) -> SecretAttachmentTargetPropspublic SecretAttachmentTargetProps asSecretAttachmentTarget()public SecretAttachmentTargetProps AsSecretAttachmentTarget()func AsSecretAttachmentTarget() SecretAttachmentTargetProps#Renders the secret attachment target specifications.
fromServerlessClusterAttributes(scope: Construct, id: string, attrs: ServerlessClusterAttributes): IServerlessCluster@staticmethod def from_serverless_cluster_attributes(scope: Construct, id: str, attrs: ServerlessClusterAttributes) -> IServerlessClusterpublic static IServerlessCluster fromServerlessClusterAttributes(Construct scope, String id, ServerlessClusterAttributes attrs)public static IServerlessCluster FromServerlessClusterAttributes(Construct scope, string id, ServerlessClusterAttributes attrs)func FromServerlessClusterAttributes(Scope Construct, Id *string, Attrs ServerlessClusterAttributes) IServerlessClusterstatic#Import an existing DatabaseCluster from properties.
grantDataApiAccess(grantee: IGrantable): Grantdef grant_data_api_access(self, grantee: IGrantable) -> Grantpublic Grant grantDataApiAccess(IGrantable grantee)public Grant GrantDataApiAccess(IGrantable grantee)func GrantDataApiAccess(Grantee IGrantable) Grant#Grant the given identity to access to the Data API, including read access to the secret attached to the cluster if present.
[disable-awslint:no-grants]
1 parameter
Parameters
granteegranteegranteegranteeGrantee— The principal to grant access to.
isConstruct(x: any): boolean@staticmethod def is_construct(x: Any) -> boolpublic static Boolean isConstruct(Object x)public static bool IsConstruct(object x)func IsConstruct(X interface{}) *boolstatic#Checks if `x` is a construct.
notes · 1 parameter · returns
Use this method instead of instanceof to properly detect Construct instances, even when the construct library is symlinked.
Explanation: in JavaScript, multiple copies of the constructs library on disk are seen as independent, completely different libraries. As a consequence, the class Construct in each copy of the constructs library is seen as a different class, and an instance of one class will not test as instanceof the other class. npm install will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the constructs library can be accidentally installed, and instanceof will behave unpredictably. It is safest to avoid using instanceof, and using this type-testing method instead.
Parameters
xxxxX— Any object.
Returns: true if x is an object created from a class which extends Construct.
isOwnedResource(construct: IConstruct): boolean@staticmethod def is_owned_resource(construct: IConstruct) -> boolpublic static Boolean isOwnedResource(IConstruct construct)public static bool IsOwnedResource(IConstruct construct)func IsOwnedResource(Construct IConstruct) *boolstatic#Returns true if the construct was created by CDK, and false otherwise.
isResource(construct: IConstruct): boolean@staticmethod def is_resource(construct: IConstruct) -> boolpublic static Boolean isResource(IConstruct construct)public static bool IsResource(IConstruct construct)func IsResource(Construct IConstruct) *boolstatic#Check whether the given construct is a Resource.
toString(): stringdef to_string(self, ) -> strpublic String toString()public string ToString()func ToString() *string#Returns a string representation of this construct.
with(...mixins: IMixin[]): IConstructdef with(self, mixins: IMixin) -> IConstructpublic IConstruct with(IMixin mixins)public IConstruct With(IMixin mixins)func With(Mixins IMixin) IConstruct#Applies one or more mixins to this construct.
Mixins are applied in order. The list of constructs is captured at the start of the call, so constructs added by a mixin will not be visited. Use multiple with() calls if subsequent mixins should apply to added constructs.