Package com.pulumi.aws.rds

Class Cluster

  • public class Cluster
extends com.pulumi.resources.CustomResource
    Manages a [RDS Aurora Cluster](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Aurora.html) or a [RDS Multi-AZ DB Cluster](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/multi-az-db-clusters-concepts.html). To manage cluster instances that inherit configuration from the cluster (when not running the cluster in `serverless` engine mode), see the `aws.rds.ClusterInstance` resource. To manage non-Aurora DB instances (e.g., MySQL, PostgreSQL, SQL Server, etc.), see the `aws.rds.Instance` resource. For information on the difference between the available Aurora MySQL engines see [Comparison between Aurora MySQL 1 and Aurora MySQL 2](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/AuroraMySQL.Updates.20180206.html) in the Amazon RDS User Guide. Changes to an RDS Cluster can occur when you manually change a parameter, such as `port`, and are reflected in the next maintenance window. Because of this, this provider may report a difference in its planning phase because a modification has not yet taken place. You can use the `applyImmediately` flag to instruct the service to apply the change immediately (see documentation below). > **Note:** Multi-AZ DB clusters are supported only for the MySQL and PostgreSQL DB engines. > **Note:** `caCertificateIdentifier` is only supported for Multi-AZ DB clusters. > **Note:** using `applyImmediately` can result in a brief downtime as the server reboots. See the AWS Docs on [RDS Maintenance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Maintenance.html) for more information. > **Note:** All arguments including the username and password will be stored in the raw state as plain-text. **NOTE on RDS Clusters and RDS Cluster Role Associations:** Pulumi provides both a standalone RDS Cluster Role Association - (an association between an RDS Cluster and a single IAM Role) and an RDS Cluster resource with `iamRoles` attributes. Use one resource or the other to associate IAM Roles and RDS Clusters. Not doing so will cause a conflict of associations and will result in the association being overwritten. ## Example Usage ### Aurora MySQL 2.x (MySQL 5.7) 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var default_ = new Cluster("default", ClusterArgs.builder()
             .clusterIdentifier("aurora-cluster-demo")
             .engine("aurora-mysql")
             .engineVersion("5.7.mysql_aurora.2.03.2")
             .availabilityZones(            
                 "us-west-2a",
                 "us-west-2b",
                 "us-west-2c")
             .databaseName("mydb")
             .masterUsername("foo")
             .masterPassword("must_be_eight_characters")
             .backupRetentionPeriod(5)
             .preferredBackupWindow("07:00-09:00")
             .build());
 
     }
 }
    ### Aurora MySQL 1.x (MySQL 5.6) 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var default_ = new Cluster("default", ClusterArgs.builder()
             .clusterIdentifier("aurora-cluster-demo")
             .availabilityZones(            
                 "us-west-2a",
                 "us-west-2b",
                 "us-west-2c")
             .databaseName("mydb")
             .masterUsername("foo")
             .masterPassword("must_be_eight_characters")
             .backupRetentionPeriod(5)
             .preferredBackupWindow("07:00-09:00")
             .build());
 
     }
 }
    ### Aurora with PostgreSQL engine 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var postgresql = new Cluster("postgresql", ClusterArgs.builder()
             .clusterIdentifier("aurora-cluster-demo")
             .engine("aurora-postgresql")
             .availabilityZones(            
                 "us-west-2a",
                 "us-west-2b",
                 "us-west-2c")
             .databaseName("mydb")
             .masterUsername("foo")
             .masterPassword("must_be_eight_characters")
             .backupRetentionPeriod(5)
             .preferredBackupWindow("07:00-09:00")
             .build());
 
     }
 }
    ### RDS Multi-AZ Cluster > More information about RDS Multi-AZ Clusters can be found in the [RDS User Guide](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/multi-az-db-clusters-concepts.html). To create a Multi-AZ RDS cluster, you must additionally specify the `engine`, `storageType`, `allocatedStorage`, `iops` and `dbClusterInstanceClass` attributes. 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var example = new Cluster("example", ClusterArgs.builder()
             .clusterIdentifier("example")
             .availabilityZones(            
                 "us-west-2a",
                 "us-west-2b",
                 "us-west-2c")
             .engine("mysql")
             .dbClusterInstanceClass("db.r6gd.xlarge")
             .storageType("io1")
             .allocatedStorage(100)
             .iops(1000)
             .masterUsername("test")
             .masterPassword("mustbeeightcharaters")
             .build());
 
     }
 }
    ### RDS Serverless v2 Cluster > More information about RDS Serverless v2 Clusters can be found in the [RDS User Guide](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2.html). > **Note:** Unlike Serverless v1, in Serverless v2 the `storageEncrypted` value is set to `false` by default. This is because Serverless v1 uses the `serverless` `engineMode`, but Serverless v2 uses the `provisioned` `engineMode`. To create a Serverless v2 RDS cluster, you must additionally specify the `engineMode` and `serverlessv2ScalingConfiguration` attributes. An `aws.rds.ClusterInstance` resource must also be added to the cluster with the `instanceClass` attribute specified. 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.inputs.ClusterServerlessv2ScalingConfigurationArgs;
 import com.pulumi.aws.rds.ClusterInstance;
 import com.pulumi.aws.rds.ClusterInstanceArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var example = new Cluster("example", ClusterArgs.builder()
             .serverlessv2ScalingConfiguration(ClusterServerlessv2ScalingConfigurationArgs.builder()
                 .maxCapacity(1.0)
                 .minCapacity(0.0)
                 .secondsUntilAutoPause(3600)
                 .build())
             .clusterIdentifier("example")
             .engine("aurora-postgresql")
             .engineMode("provisioned")
             .engineVersion("13.6")
             .databaseName("test")
             .masterUsername("test")
             .masterPassword("must_be_eight_characters")
             .storageEncrypted(true)
             .build());
 
         var exampleClusterInstance = new ClusterInstance("exampleClusterInstance", ClusterInstanceArgs.builder()
             .clusterIdentifier(example.id())
             .instanceClass("db.serverless")
             .engine(example.engine())
             .engineVersion(example.engineVersion())
             .build());
 
     }
 }
    ### RDS/Aurora Managed Master Passwords via Secrets Manager, default KMS Key > More information about RDS/Aurora Aurora integrates with Secrets Manager to manage master user passwords for your DB clusters can be found in the [RDS User Guide](https://aws.amazon.com/about-aws/whats-new/2022/12/amazon-rds-integration-aws-secrets-manager/) and [Aurora User Guide](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-secrets-manager.html). You can specify the `manageMasterUserPassword` attribute to enable managing the master password with Secrets Manager. You can also update an existing cluster to use Secrets Manager by specify the `manageMasterUserPassword` attribute and removing the `masterPassword` attribute (removal is required). 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var test = new Cluster("test", ClusterArgs.builder()
             .clusterIdentifier("example")
             .databaseName("test")
             .manageMasterUserPassword(true)
             .masterUsername("test")
             .build());
 
     }
 }
    ### RDS/Aurora Managed Master Passwords via Secrets Manager, specific KMS Key > More information about RDS/Aurora Aurora integrates with Secrets Manager to manage master user passwords for your DB clusters can be found in the [RDS User Guide](https://aws.amazon.com/about-aws/whats-new/2022/12/amazon-rds-integration-aws-secrets-manager/) and [Aurora User Guide](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-secrets-manager.html). You can specify the `masterUserSecretKmsKeyId` attribute to specify a specific KMS Key. 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.kms.Key;
 import com.pulumi.aws.kms.KeyArgs;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var example = new Key("example", KeyArgs.builder()
             .description("Example KMS Key")
             .build());
 
         var test = new Cluster("test", ClusterArgs.builder()
             .clusterIdentifier("example")
             .databaseName("test")
             .manageMasterUserPassword(true)
             .masterUsername("test")
             .masterUserSecretKmsKeyId(example.keyId())
             .build());
 
     }
 }
    ### Disabling Master Password Rotation > **Note:** The `aws.secretsmanager.SecretRotation` resource must depend on a cluster instance, otherwise AWS re-enables rotation once the instance finishes provisioning. Use `dependsOn` as shown below when the cluster and its instance are created together. When `manageMasterUserPassword` is enabled, Secrets Manager rotates the master user password automatically (every 7 days by default). To disable that rotation while keeping the managed secret, manage the secret's rotation with `aws.secretsmanager.SecretRotation` and set `rotationEnabled = false`. 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.ClusterInstance;
 import com.pulumi.aws.rds.ClusterInstanceArgs;
 import com.pulumi.aws.secretsmanager.SecretRotation;
 import com.pulumi.aws.secretsmanager.SecretRotationArgs;
 import com.pulumi.resources.CustomResourceOptions;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var test = new Cluster("test", ClusterArgs.builder()
             .clusterIdentifier("example")
             .databaseName("test")
             .manageMasterUserPassword(true)
             .masterUsername("test")
             .build());
 
         var testClusterInstance = new ClusterInstance("testClusterInstance", ClusterInstanceArgs.builder()
             .clusterIdentifier(test.id())
             .identifier("example-1")
             .instanceClass("db.r6g.large")
             .engine(test.engine())
             .engineVersion(test.engineVersion())
             .build());
 
         var testSecretRotation = new SecretRotation("testSecretRotation", SecretRotationArgs.builder()
             .secretId(test.masterUserSecrets().applyValue(_masterUserSecrets -> _masterUserSecrets[0].secretArn()))
             .rotationEnabled(false)
             .build(), CustomResourceOptions.builder()
                 .dependsOn(testClusterInstance)
                 .build());
 
     }
 }
    ### Global Cluster Restored From Snapshot 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.RdsFunctions;
 import com.pulumi.aws.rds.inputs.GetClusterSnapshotArgs;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.GlobalCluster;
 import com.pulumi.aws.rds.GlobalClusterArgs;
 import com.pulumi.resources.CustomResourceOptions;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 example = RdsFunctions.getClusterSnapshot(GetClusterSnapshotArgs.builder()
             .dbClusterIdentifier("example-original-cluster")
             .mostRecent(true)
             .build());
 
         var exampleCluster = new Cluster("exampleCluster", ClusterArgs.builder()
             .engine("aurora")
             .engineVersion("5.6.mysql_aurora.1.22.4")
             .clusterIdentifier("example")
             .snapshotIdentifier(example.id())
             .build(), CustomResourceOptions.builder()
                 .ignoreChanges("snapshotIdentifier", "globalClusterIdentifier")
                 .build());
 
         var exampleGlobalCluster = new GlobalCluster("exampleGlobalCluster", GlobalClusterArgs.builder()
             .globalClusterIdentifier("example")
             .sourceDbClusterIdentifier(exampleCluster.arn())
             .forceDestroy(true)
             .build());
 
     }
 }
    ### Restore From S3 Full details on the core parameters and impacts are in the API Docs: [RestoreDBClusterFromS3](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromS3.html). Requires that the S3 bucket be in the same region as the RDS cluster you're trying to create. > **NOTE:** RDS Aurora Serverless does not support loading data from S3, so its not possible to directly use `engineMode` set to `serverless` with `s3Import`. 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.inputs.ClusterS3ImportArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var db = new Cluster("db", ClusterArgs.builder()
             .s3Import(ClusterS3ImportArgs.builder()
                 .sourceEngine("mysql")
                 .sourceEngineVersion("5.6")
                 .bucketName("mybucket")
                 .bucketPrefix("backups")
                 .ingestionRole("arn:aws:iam::1234567890:role/role-xtrabackup-rds-restore")
                 .build())
             .engine("aurora")
             .build());
 
     }
 }
    ### Restore To Point In Time 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.inputs.ClusterRestoreToPointInTimeArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var example_clone = new Cluster("example-clone", ClusterArgs.builder()
             .restoreToPointInTime(ClusterRestoreToPointInTimeArgs.builder()
                 .sourceClusterIdentifier("example")
                 .restoreType("copy-on-write")
                 .useLatestRestorableTime(true)
                 .build())
             .build());
 
     }
 }
    ### Serverless v1 Scaling Configuration 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.inputs.ClusterScalingConfigurationArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var example = new Cluster("example", ClusterArgs.builder()
             .scalingConfiguration(ClusterScalingConfigurationArgs.builder()
                 .autoPause(true)
                 .maxCapacity(256)
                 .minCapacity(2)
                 .secondsBeforeTimeout(360)
                 .secondsUntilAutoPause(300)
                 .timeoutAction("ForceApplyCapacityChange")
                 .build())
             .engineMode("serverless")
             .build());
 
     }
 }
    ### Serverless v2 Scaling Configuration 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.rds.Cluster;
 import com.pulumi.aws.rds.ClusterArgs;
 import com.pulumi.aws.rds.inputs.ClusterServerlessv2ScalingConfigurationArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         var example = new Cluster("example", ClusterArgs.builder()
             .serverlessv2ScalingConfiguration(ClusterServerlessv2ScalingConfigurationArgs.builder()
                 .maxCapacity(256.0)
                 .minCapacity(0.0)
                 .secondsUntilAutoPause(3600)
                 .build())
             .build());
 
     }
 }
    ## Import ### Identity Schema #### Required * `clusterIdentifier` (String) Cluster identifier of the RDS Cluster. #### Optional * `accountId` (String) AWS Account where this resource is managed. * `region` (String) Region where this resource is managed. Using `pulumi import`, import RDS Clusters using the `clusterIdentifier`. For example: ```sh $ pulumi import aws:rds/cluster:Cluster aurora_cluster aurora-prod-cluster ```

    • Constructor Detail

      • Cluster

        public Cluster​(java.lang.String name)
        Parameters:
        name - The _unique_ name of the resulting resource.

      • Cluster

        public Cluster​(java.lang.String name,
               ClusterArgs args)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.

      • Cluster

        public Cluster​(java.lang.String name,
               ClusterArgs args,
               @Nullable
               com.pulumi.resources.CustomResourceOptions options)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.
        options - A bag of options that control this resource's behavior.

    • Method Detail

      • allocatedStorage

        public com.pulumi.core.Output<java.lang.Integer> allocatedStorage()
        Returns:
        Amount of storage in gibibytes (GiB) to allocate to each DB instance in the Multi-AZ DB cluster.

      • allowMajorVersionUpgrade

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> allowMajorVersionUpgrade()
        Returns:
        Enable to allow major engine version upgrades when changing engine versions. Defaults to `false`.

      • applyImmediately

        public com.pulumi.core.Output<java.lang.Boolean> applyImmediately()
        Returns:
        Whether any cluster modifications are applied immediately, or during the next maintenance window. Default is `false`. See [Amazon RDS Documentation for more information.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html)

      • arn

        public com.pulumi.core.Output<java.lang.String> arn()
        Returns:
        ARN of cluster

      • autoMinorVersionUpgrade

        public com.pulumi.core.Output<java.lang.Boolean> autoMinorVersionUpgrade()
        Returns:
        Whether to apply minor engine upgrades automatically to the DB cluster during the maintenance window. Defaults to `true`.

      • availabilityZones

        public com.pulumi.core.Output<java.util.List<java.lang.String>> availabilityZones()
        Returns:
        List of EC2 Availability Zones for the DB cluster storage where DB cluster instances can be created. RDS automatically assigns 3 AZs if less than 3 AZs are configured, which will show as a difference requiring resource recreation next pulumi up. We recommend specifying 3 AZs or using the `lifecycle` configuration block `ignoreChanges` argument if necessary. A maximum of 3 AZs can be configured. **Note:** [Multi-AZ DB clusters](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/multi-az-db-clusters-concepts.html) require exactly 3 Availability Zones in the DB subnet group. Aurora DB clusters can operate with fewer AZs, but RDS will still automatically assign 3 AZs as described above. **Note:** Do not set `availabilityZones` to the output of a data source such as `aws.getAvailabilityZones`, as this may be subject to change (for example, when a new AZ is added to a Region). Changing `availabilityZones` forces a replacement, which will destroy and recreate the cluster. Always use an explicit, static list of AZs.

      • backtrackWindow

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> backtrackWindow()
        Returns:
        Target backtrack window, in seconds. Only available for `aurora` and `aurora-mysql` engines currently. To disable backtracking, set this value to `0`. Defaults to `0`. Must be between `0` and `259200` (72 hours)

      • backupRetentionPeriod

        public com.pulumi.core.Output<java.lang.Integer> backupRetentionPeriod()
        Returns:
        Days to retain backups for. Default `1`

      • caCertificateIdentifier

        public com.pulumi.core.Output<java.lang.String> caCertificateIdentifier()
        Returns:
        CA certificate identifier to use for the DB cluster's server certificate.

      • caCertificateValidTill

        public com.pulumi.core.Output<java.lang.String> caCertificateValidTill()
        Returns:
        Expiration date of the DB instance’s server certificate

      • clusterIdentifier

        public com.pulumi.core.Output<java.lang.String> clusterIdentifier()
        Returns:
        Cluster identifier. If omitted, this provider will assign a random, unique identifier.

      • clusterIdentifierPrefix

        public com.pulumi.core.Output<java.lang.String> clusterIdentifierPrefix()
        Returns:
        Creates a unique cluster identifier beginning with the specified prefix. Conflicts with `clusterIdentifier`.

      • clusterMembers

        public com.pulumi.core.Output<java.util.List<java.lang.String>> clusterMembers()
        Returns:
        List of RDS Instances that are a part of this cluster

      • clusterResourceId

        public com.pulumi.core.Output<java.lang.String> clusterResourceId()
        Returns:
        RDS Cluster Resource ID

      • clusterScalabilityType

        public com.pulumi.core.Output<java.lang.String> clusterScalabilityType()
        Returns:
        Scalability mode of the Aurora DB cluster. When set to `limitless`, the cluster operates as an Aurora Limitless Database. When set to `standard` (the default), the cluster uses normal DB instance creation. Valid values: `limitless`, `standard`.

      • copyTagsToSnapshot

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> copyTagsToSnapshot()
        Returns:
        Copy all Cluster `tags` to snapshots. Default is `false`.

      • databaseInsightsMode

        public com.pulumi.core.Output<java.lang.String> databaseInsightsMode()
        Returns:
        Mode of Database Insights to enable for the DB cluster. Valid values: `standard`, `advanced`.

      • databaseName

        public com.pulumi.core.Output<java.lang.String> databaseName()
        Returns:
        Name for an automatically created database on cluster creation. There are different naming restrictions per database engine: [RDS Naming Constraints](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.Constraints)

      • dbClusterInstanceClass

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> dbClusterInstanceClass()
        Returns:
        Compute and memory capacity of each DB instance in the Multi-AZ DB cluster, for example `db.m6g.xlarge`. Not all DB instance classes are available in all AWS Regions, or for all database engines. For the full list of DB instance classes and availability for your engine, see [DB instance class](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html) in the Amazon RDS User Guide.

      • dbClusterParameterGroupName

        public com.pulumi.core.Output<java.lang.String> dbClusterParameterGroupName()
        Returns:
        Cluster parameter group to associate with the cluster.

      • dbInstanceParameterGroupName

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> dbInstanceParameterGroupName()
        Returns:
        Instance parameter group to associate with all instances of the DB cluster. The `dbInstanceParameterGroupName` parameter is only valid in combination with the `allowMajorVersionUpgrade` parameter.

      • dbSubnetGroupName

        public com.pulumi.core.Output<java.lang.String> dbSubnetGroupName()
        Returns:
        DB subnet group to associate with this DB cluster. **NOTE:** This must match the `dbSubnetGroupName` specified on every `aws.rds.ClusterInstance` in the cluster.

      • dbSystemId

        public com.pulumi.core.Output<java.lang.String> dbSystemId()
        Returns:
        For use with RDS Custom.

      • deleteAutomatedBackups

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> deleteAutomatedBackups()
        Returns:
        Whether to remove automated backups immediately after the DB cluster is deleted. Default is `true`.

      • deletionProtection

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> deletionProtection()
        Returns:
        If the DB cluster should have deletion protection enabled. The database can't be deleted when this value is set to `true`. The default is `false`.

      • domain

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> domain()
        Returns:
        ID of the Directory Service Active Directory domain to create the cluster in.

      • domainIamRoleName

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> domainIamRoleName()
        Returns:
        Name of the IAM role to be used when making API calls to the Directory Service.

      • enableGlobalWriteForwarding

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> enableGlobalWriteForwarding()
        Returns:
        Whether cluster should forward writes to an associated global cluster. Applied to secondary clusters to enable them to forward writes to an `aws.rds.GlobalCluster`'s primary cluster. See the [User Guide for Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-write-forwarding.html) for more information.

      • enableHttpEndpoint

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> enableHttpEndpoint()
        Returns:
        Enable HTTP endpoint (data API). Only valid for some combinations of `engineMode`, `engine` and `engineVersion` and only available in some regions. See the [Region and version availability](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html#data-api.regions) section of the documentation. This option also does not work with any of these options specified: `snapshotIdentifier`, `replicationSourceIdentifier`, `s3Import`.

      • enableLocalWriteForwarding

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> enableLocalWriteForwarding()
        Returns:
        Whether read replicas can forward write operations to the writer DB instance in the DB cluster. By default, write operations aren't allowed on reader DB instances. See the [User Guide for Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-mysql-write-forwarding.html) for more information. **NOTE:** Local write forwarding requires Aurora MySQL version 3.04 or higher.

      • enabledCloudwatchLogsExports

        public com.pulumi.core.Output<java.util.Optional<java.util.List<java.lang.String>>> enabledCloudwatchLogsExports()
        Returns:
        Set of log types to export to CloudWatch. If omitted, no logs will be exported. The following log types are supported: `audit`, `error`, `general`, `iam-db-auth-error`, `instance`, `postgresql` (PostgreSQL), `slowquery`.

      • endpoint

        public com.pulumi.core.Output<java.lang.String> endpoint()
        Returns:
        DNS address of the RDS instance

      • engine

        public com.pulumi.core.Output<java.lang.String> engine()
        Returns:
        Name of the database engine to be used for this DB cluster. Valid Values: `aurora-mysql`, `aurora-postgresql`, `mysql`, `postgres`. (Note that `mysql` and `postgres` are Multi-AZ RDS clusters).

      • engineLifecycleSupport

        public com.pulumi.core.Output<java.lang.String> engineLifecycleSupport()
        Returns:
        Life cycle type for this DB instance. This setting is valid for cluster types Aurora DB clusters and Multi-AZ DB clusters. Valid values are `open-source-rds-extended-support`, `open-source-rds-extended-support-disabled`. Default value is `open-source-rds-extended-support`. [Using Amazon RDS Extended Support]: https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/extended-support.html

      • engineMode

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> engineMode()
        Returns:
        Database engine mode. Valid values: `global` (only valid for Aurora MySQL 1.21 and earlier), `parallelquery`, `provisioned`, `serverless`. Defaults to: `provisioned`. Specify an empty value (`""`) for no engine mode. See the [RDS User Guide](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.html) for limitations when using `serverless`.

      • engineVersion

        public com.pulumi.core.Output<java.lang.String> engineVersion()
        Returns:
        Database engine version. Updating this argument results in an outage. See the [Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Updates.html) and [Aurora Postgres](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Updates.html) documentation for your configured engine to determine this value, or by running `aws rds describe-db-engine-versions`. For example with Aurora MySQL 2, a potential value for this argument is `5.7.mysql_aurora.2.03.2`. The value can contain a partial version where supported by the API. The actual engine version used is returned in the attribute `engineVersionActual`, see Attribute Reference below.

      • engineVersionActual

        public com.pulumi.core.Output<java.lang.String> engineVersionActual()
        Returns:
        Running version of the database.

      • finalSnapshotIdentifier

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> finalSnapshotIdentifier()
        Returns:
        Name of your final DB snapshot when this DB cluster is deleted. If omitted, no final snapshot will be made.

      • globalClusterIdentifier

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> globalClusterIdentifier()
        Returns:
        Global cluster identifier specified on `aws.rds.GlobalCluster`.

      • hostedZoneId

        public com.pulumi.core.Output<java.lang.String> hostedZoneId()
        Returns:
        Route53 Hosted Zone ID of the endpoint

      • iamDatabaseAuthenticationEnabled

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> iamDatabaseAuthenticationEnabled()
        Returns:
        Whether mappings of AWS Identity and Access Management (IAM) accounts to database accounts is enabled. Please see [AWS Documentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.html) for availability and limitations.

      • iamRoles

        public com.pulumi.core.Output<java.util.List<java.lang.String>> iamRoles()
        Returns:
        List of ARNs for the IAM roles to associate to the RDS Cluster.

      • iops

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> iops()
        Returns:
        Amount of Provisioned IOPS (input/output operations per second) to be initially allocated for each DB instance in the Multi-AZ DB cluster. For information about valid Iops values, see [Amazon RDS Provisioned IOPS storage to improve performance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html#USER_PIOPS) in the Amazon RDS User Guide. (This setting is required to create a Multi-AZ DB cluster). Must be a multiple between .5 and 50 of the storage amount for the DB cluster.

      • kmsKeyId

        public com.pulumi.core.Output<java.lang.String> kmsKeyId()
        Returns:
        ARN for the KMS encryption key. When specifying `kmsKeyId`, `storageEncrypted` needs to be set to true.

      • manageMasterUserPassword

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> manageMasterUserPassword()
        Returns:
        Set to true to allow RDS to manage the master user password in Secrets Manager. Cannot be set if `masterPassword` is provided.

      • masterPassword

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> masterPassword()
        Returns:
        Password for the master DB user. Note that this may show up in logs, and it will be stored in the state file. Please refer to the [RDS Naming Constraints](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.Constraints). Cannot be set if `manageMasterUserPassword` is set to `true`.

      • masterPasswordWo

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> masterPasswordWo()
        Returns:
        **NOTE:** This field is write-only and its value will not be updated in state as part of read operations. Password for the master DB user. Note that this may show up in logs. Please refer to the [RDS Naming Constraints](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.Constraints). Cannot be set if `manageMasterUserPassword` is set to `true`. If set, requires `masterPasswordWoVersion` to be set.

      • masterPasswordWoVersion

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> masterPasswordWoVersion()
        Returns:
        Required when `masterPasswordWo` is set. Changing this value triggers an update to `masterPasswordWo`.

      • masterUserSecretKmsKeyId

        public com.pulumi.core.Output<java.lang.String> masterUserSecretKmsKeyId()
        Returns:
        Amazon Web Services KMS key identifier is the key ARN, key ID, alias ARN, or alias name for the KMS key. To use a KMS key in a different Amazon Web Services account, specify the key ARN or alias ARN. If not specified, the default KMS key for your Amazon Web Services account is used.

      • masterUserSecrets

        public com.pulumi.core.Output<java.util.List<ClusterMasterUserSecret>> masterUserSecrets()
        Returns:
        Block that specifies the master user secret. Only available when `manageMasterUserPassword` is set to true. Documented below.

      • masterUsername

        public com.pulumi.core.Output<java.lang.String> masterUsername()
        Returns:
        Username for the master DB user. Please refer to the [RDS Naming Constraints](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.Constraints). This argument does not support in-place updates and cannot be changed during a restore from snapshot.

      • monitoringInterval

        public com.pulumi.core.Output<java.lang.Integer> monitoringInterval()
        Returns:
        Interval, in seconds, between points when Enhanced Monitoring metrics are collected for the DB cluster. To turn off collecting Enhanced Monitoring metrics, specify 0. The default is 0. Valid Values: 0, 1, 5, 10, 15, 30, 60.

      • monitoringRoleArn

        public com.pulumi.core.Output<java.lang.String> monitoringRoleArn()
        Returns:
        ARN for the IAM role that permits RDS to send enhanced monitoring metrics to CloudWatch Logs. You can find more information on the [AWS Documentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Monitoring.html#USER_Monitoring.OS.IAMRole.html) what IAM permissions are needed to allow Enhanced Monitoring for RDS Clusters.

      • networkType

        public com.pulumi.core.Output<java.lang.String> networkType()
        Returns:
        Network type of the cluster. Valid values: `IPV4`, `DUAL`.

      • performanceInsightsEnabled

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> performanceInsightsEnabled()
        Returns:
        Enables Performance Insights.

      • performanceInsightsKmsKeyId

        public com.pulumi.core.Output<java.lang.String> performanceInsightsKmsKeyId()
        Returns:
        KMS Key ID to encrypt Performance Insights data. If not specified, the default RDS KMS key will be used (`aws/rds`).

      • performanceInsightsRetentionPeriod

        public com.pulumi.core.Output<java.lang.Integer> performanceInsightsRetentionPeriod()
        Returns:
        Amount of time to retain performance insights data for. Defaults to 7 days if Performance Insights are enabled. Valid values are `7`, `month * 31` (where month is a number of months from 1-23), and `731`. See [here](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_PerfInsights.Overview.cost.html) for more information on retention periods.

      • port

        public com.pulumi.core.Output<java.lang.Integer> port()
        Returns:
        Port on which the DB accepts connections.

      • preferredBackupWindow

        public com.pulumi.core.Output<java.lang.String> preferredBackupWindow()
        Returns:
        Daily time range during which automated backups are created if automated backups are enabled using the BackupRetentionPeriod parameter.Time in UTC. Default: A 30-minute window selected at random from an 8-hour block of time per region, e.g. `04:00-09:00`.

      • preferredMaintenanceWindow

        public com.pulumi.core.Output<java.lang.String> preferredMaintenanceWindow()
        Returns:
        Weekly time range during which system maintenance can occur, in (UTC) e.g., `wed:04:00-wed:04:30`

      • publiclyAccessible

        public com.pulumi.core.Output<java.lang.Boolean> publiclyAccessible()
        Returns:
        Whether the DB cluster is publicly accessible. Valid only for Multi-AZ DB clusters. If not specified, defaults to `true` when `dbSubnetGroupName` is not set or is `default`, and `false` otherwise. If `true`, the VPC of the DB subnet group must have an internet gateway attached. Cannot be used with `s3Import`.

      • readerEndpoint

        public com.pulumi.core.Output<java.lang.String> readerEndpoint()
        Returns:
        Read-only endpoint for the Aurora cluster, automatically load-balanced across replicas

      • region

        public com.pulumi.core.Output<java.lang.String> region()
        Returns:
        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

      • replicationSourceIdentifier

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> replicationSourceIdentifier()
        Returns:
        ARN of a source DB cluster or DB instance if this DB cluster is to be created as a Read Replica. **Note:** Removing this attribute after creation will promote the read replica to a standalone cluster. If DB Cluster is part of a Global Cluster, use the `ignoreChanges` resource option to prevent Pulumi from showing differences for this argument instead of configuring this value.

      • restoreToPointInTime

        public com.pulumi.core.Output<java.util.Optional<ClusterRestoreToPointInTime>> restoreToPointInTime()
        Returns:
        Nested attribute for [point in time restore](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-pitr.html). More details below.

      • s3Import

        public com.pulumi.core.Output<java.util.Optional<ClusterS3Import>> s3Import()

      • scalingConfiguration

        public com.pulumi.core.Output<java.util.Optional<ClusterScalingConfiguration>> scalingConfiguration()
        Returns:
        Nested attribute with scaling properties. Only valid when `engineMode` is set to `serverless`. More details below.

      • serverlessv2ScalingConfiguration

        public com.pulumi.core.Output<java.util.Optional<ClusterServerlessv2ScalingConfiguration>> serverlessv2ScalingConfiguration()
        Returns:
        Nested attribute with scaling properties for ServerlessV2. Only valid when `engineMode` is set to `provisioned`. More details below.

      • skipFinalSnapshot

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> skipFinalSnapshot()
        Returns:
        Whether a final DB snapshot is created before the DB cluster is deleted. If true is specified, no DB snapshot is created. If false is specified, a DB snapshot is created before the DB cluster is deleted, using the value from `finalSnapshotIdentifier`. Default is `false`.

      • snapshotIdentifier

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> snapshotIdentifier()
        Returns:
        Whether to create this cluster from a snapshot. You can use either the name or ARN when specifying a DB cluster snapshot, or the ARN when specifying a DB snapshot. Conflicts with `globalClusterIdentifier`. Clusters cannot be restored from snapshot **and** joined to an existing global cluster in a single operation. See the [AWS documentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database.use-snapshot) or the Global Cluster Restored From Snapshot example for instructions on building a global cluster starting with a snapshot.

      • sourceRegion

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> sourceRegion()
        Returns:
        Source region for an encrypted replica DB cluster.

      • storageEncrypted

        public com.pulumi.core.Output<java.lang.Boolean> storageEncrypted()
        Returns:
        Whether the DB cluster is encrypted. The default is `false` for `provisioned` `engineMode` and `true` for `serverless` `engineMode`. When restoring an unencrypted `snapshotIdentifier`, the `kmsKeyId` argument must be provided to encrypt the restored cluster. The provider will only perform drift detection if a configuration value is provided.

      • storageType

        public com.pulumi.core.Output<java.lang.String> storageType()
        Returns:
        (Forces new for Multi-AZ DB clusters) Specifies the storage type to be associated with the DB cluster. For Aurora DB clusters, `storageType` modifications can be done in-place. For Multi-AZ DB Clusters, the `iops` argument must also be set. Valid values are: `""`, `aurora-iopt1` (Aurora DB Clusters); `io1`, `io2`, `gp3` (Multi-AZ DB Clusters). Default: `""` (Aurora DB Clusters); `io1` (Multi-AZ DB Clusters).

      • tags

        public com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,​java.lang.String>>> tags()
        Returns:
        Map of tags to assign to the DB cluster. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

      • tagsAll

        public com.pulumi.core.Output<java.util.Map<java.lang.String,​java.lang.String>> tagsAll()
        Returns:
        Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

      • upgradeRolloutOrder

        public com.pulumi.core.Output<java.lang.String> upgradeRolloutOrder()
        Returns:
        Order in which the clusters are upgraded (`first`, `second`, `last`). See [the AWS documentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Maintenance.AMVU.UpgradeRollout.html) for details.

      • vpcSecurityGroupIds

        public com.pulumi.core.Output<java.util.List<java.lang.String>> vpcSecurityGroupIds()
        Returns:
        List of VPC security groups to associate with the Cluster

      • warningEventCategories

        public com.pulumi.core.Output<java.util.Optional<java.util.List<java.lang.String>>> warningEventCategories()
        Returns:
        Set of RDS event categories (for example `failure`, `maintenance`) to check for after create and update operations. If set, the provider describes RDS events reported for this cluster during the operation and surfaces a warning diagnostic, with the RDS event message, for each one found in these categories. Has no effect if unset; see [DescribeEvents](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEvents.html) and the `aws.rds.getEvents` data source for the source of these events. Requires the `rds:DescribeEvents` IAM permission when set.

      • get

        public static Cluster get​(java.lang.String name,
                          com.pulumi.core.Output<java.lang.String> id,
                          @Nullable
                          ClusterState state,
                          @Nullable
                          com.pulumi.resources.CustomResourceOptions options)
        Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
        Parameters:
        name - The _unique_ name of the resulting resource.
        id - The _unique_ provider ID of the resource to lookup.
        state -
        options - Optional settings to control the behavior of the CustomResource.