ClusterActivityStream class
Manages RDS Aurora Cluster Database Activity Streams.
Database Activity Streams have some limits and requirements, refer to the Monitoring Amazon Aurora using Database Activity Streams documentation for detailed limitations and requirements.
> Note: This resource always calls the RDS StartActivityStream API with the ApplyImmediately parameter set to true. This is because the provider needs the activity stream to be started in order for it to get the associated attributes.
> Note: This resource depends on having at least one aws.rds.ClusterInstance created. To avoid race conditions when all resources are being created together, add an explicit resource reference using the resource dependsOn meta-argument.
> Note: This resource is available in all regions except the following: cn-north-1, cn-northwest-1, us-gov-east-1, us-gov-west-1
Example Usage
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const _default = new aws.rds.Cluster("default", {
clusterIdentifier: "aurora-cluster-demo",
availabilityZones: [
"us-west-2a",
"us-west-2b",
"us-west-2c",
],
databaseName: "mydb",
masterUsername: "foo",
masterPassword: "mustbeeightcharaters",
engine: aws.rds.EngineType.AuroraPostgresql,
engineVersion: "13.4",
});
const defaultClusterInstance = new aws.rds.ClusterInstance("default", {
identifier: "aurora-instance-demo",
clusterIdentifier: _default.clusterIdentifier,
engine: _default.engine.apply((x) => aws.rds.EngineType[x]),
instanceClass: aws.rds.InstanceType.R6G_Large,
});
const defaultKey = new aws.kms.Key("default", {description: "AWS KMS Key to encrypt Database Activity Stream"});
const defaultClusterActivityStream = new aws.rds.ClusterActivityStream("default", {
resourceArn: _default.arn,
mode: "async",
kmsKeyId: defaultKey.keyId,
}, {
dependsOn: [defaultClusterInstance],
});
import pulumi
import pulumi_aws as aws
default = aws.rds.Cluster("default",
cluster_identifier="aurora-cluster-demo",
availability_zones=[
"us-west-2a",
"us-west-2b",
"us-west-2c",
],
database_name="mydb",
master_username="foo",
master_password="mustbeeightcharaters",
engine=aws.rds.EngineType.AURORA_POSTGRESQL,
engine_version="13.4")
default_cluster_instance = aws.rds.ClusterInstance("default",
identifier="aurora-instance-demo",
cluster_identifier=default.cluster_identifier,
engine=default.engine.apply(lambda x: aws.rds.EngineType(x)),
instance_class=aws.rds.InstanceType.R6_G_LARGE)
default_key = aws.kms.Key("default", description="AWS KMS Key to encrypt Database Activity Stream")
default_cluster_activity_stream = aws.rds.ClusterActivityStream("default",
resource_arn=default.arn,
mode="async",
kms_key_id=default_key.key_id,
opts = pulumi.ResourceOptions(depends_on=[default_cluster_instance]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var @default = new Aws.Rds.Cluster("default", new()
{
ClusterIdentifier = "aurora-cluster-demo",
AvailabilityZones = new[]
{
"us-west-2a",
"us-west-2b",
"us-west-2c",
},
DatabaseName = "mydb",
MasterUsername = "foo",
MasterPassword = "mustbeeightcharaters",
Engine = Aws.Rds.EngineType.AuroraPostgresql,
EngineVersion = "13.4",
});
var defaultClusterInstance = new Aws.Rds.ClusterInstance("default", new()
{
Identifier = "aurora-instance-demo",
ClusterIdentifier = @default.ClusterIdentifier,
Engine = @default.Engine.Apply(System.Enum.Parse<Aws.Rds.EngineType>),
InstanceClass = Aws.Rds.InstanceType.R6G_Large,
});
var defaultKey = new Aws.Kms.Key("default", new()
{
Description = "AWS KMS Key to encrypt Database Activity Stream",
});
var defaultClusterActivityStream = new Aws.Rds.ClusterActivityStream("default", new()
{
ResourceArn = @default.Arn,
Mode = "async",
KmsKeyId = defaultKey.KeyId,
}, new CustomResourceOptions
{
DependsOn =
{
defaultClusterInstance,
},
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/kms"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/rds"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_default, err := rds.NewCluster(ctx, "default", &rds.ClusterArgs{
ClusterIdentifier: pulumi.String("aurora-cluster-demo"),
AvailabilityZones: pulumi.StringArray{
pulumi.String("us-west-2a"),
pulumi.String("us-west-2b"),
pulumi.String("us-west-2c"),
},
DatabaseName: pulumi.String("mydb"),
MasterUsername: pulumi.String("foo"),
MasterPassword: pulumi.String("mustbeeightcharaters"),
Engine: pulumi.String(rds.EngineTypeAuroraPostgresql),
EngineVersion: pulumi.String("13.4"),
})
if err != nil {
return err
}
defaultClusterInstance, err := rds.NewClusterInstance(ctx, "default", &rds.ClusterInstanceArgs{
Identifier: pulumi.String("aurora-instance-demo"),
ClusterIdentifier: _default.ClusterIdentifier,
Engine: _default.Engine.ApplyT(func(x *string) rds.EngineType { return rds.EngineType(*x) }).(rds.EngineTypeOutput),
InstanceClass: pulumi.String(rds.InstanceType_R6G_Large),
})
if err != nil {
return err
}
defaultKey, err := kms.NewKey(ctx, "default", &kms.KeyArgs{
Description: pulumi.String("AWS KMS Key to encrypt Database Activity Stream"),
})
if err != nil {
return err
}
_, err = rds.NewClusterActivityStream(ctx, "default", &rds.ClusterActivityStreamArgs{
ResourceArn: _default.Arn,
Mode: pulumi.String("async"),
KmsKeyId: defaultKey.KeyId,
}, pulumi.DependsOn([]pulumi.Resource{
defaultClusterInstance,
}))
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_rds_cluster" "default" {
cluster_identifier = "aurora-cluster-demo"
availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"]
database_name = "mydb"
master_username = "foo"
master_password = "mustbeeightcharaters"
engine = "aurora-postgresql"
engine_version = "13.4"
}
resource "aws_rds_clusterinstance" "default" {
identifier = "aurora-instance-demo"
cluster_identifier = aws_rds_cluster.default.cluster_identifier
engine = aws_rds_cluster.default.engine
instance_class = "db.r6g.large"
}
resource "aws_kms_key" "default" {
description = "AWS KMS Key to encrypt Database Activity Stream"
}
resource "aws_rds_clusteractivitystream" "default" {
depends_on = [aws_rds_clusterinstance.default]
resource_arn = aws_rds_cluster.default.arn
mode = "async"
kms_key_id = aws_kms_key.default.key_id
}
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.kms.Key;
import com.pulumi.aws.kms.KeyArgs;
import com.pulumi.aws.rds.ClusterActivityStream;
import com.pulumi.aws.rds.ClusterActivityStreamArgs;
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 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("mustbeeightcharaters")
.engine("aurora-postgresql")
.engineVersion("13.4")
.build());
var defaultClusterInstance = new ClusterInstance("defaultClusterInstance", ClusterInstanceArgs.builder()
.identifier("aurora-instance-demo")
.clusterIdentifier(default_.clusterIdentifier())
.engine(default_.engine())
.instanceClass("db.r6g.large")
.build());
var defaultKey = new Key("defaultKey", KeyArgs.builder()
.description("AWS KMS Key to encrypt Database Activity Stream")
.build());
var defaultClusterActivityStream = new ClusterActivityStream("defaultClusterActivityStream", ClusterActivityStreamArgs.builder()
.resourceArn(default_.arn())
.mode("async")
.kmsKeyId(defaultKey.keyId())
.build(), CustomResourceOptions.builder()
.dependsOn(defaultClusterInstance)
.build());
}
}
resources:
default:
type: aws:rds:Cluster
properties:
clusterIdentifier: aurora-cluster-demo
availabilityZones:
- us-west-2a
- us-west-2b
- us-west-2c
databaseName: mydb
masterUsername: foo
masterPassword: mustbeeightcharaters
engine: aurora-postgresql
engineVersion: '13.4'
defaultClusterInstance:
type: aws:rds:ClusterInstance
name: default
properties:
identifier: aurora-instance-demo
clusterIdentifier: ${default.clusterIdentifier}
engine: ${default.engine}
instanceClass: db.r6g.large
defaultKey:
type: aws:kms:Key
name: default
properties:
description: AWS KMS Key to encrypt Database Activity Stream
defaultClusterActivityStream:
type: aws:rds:ClusterActivityStream
name: default
properties:
resourceArn: ${default.arn}
mode: async
kmsKeyId: ${defaultKey.keyId}
options:
dependsOn:
- ${defaultClusterInstance}
Import
Using pulumi import, import RDS Aurora Cluster Database Activity Streams using the resourceArn. For example:
$ pulumi import aws:rds/clusterActivityStream:ClusterActivityStream default arn:aws:rds:us-west-2:123456789012:cluster:aurora-cluster-demo
Constructors
- ClusterActivityStream(String name, {ClusterActivityStreamArgs? args, CustomResourceOptions? options})
-
Creates a new ClusterActivityStream.
nameThe Pulumi resource name.argsArguments used to configure this ClusterActivityStream. The set of arguments for ClusterActivityStream.optionsResource options controlling this resource's behavior. - ClusterActivityStream.reference(String urn)
- Creates a typed reference to an existing ClusterActivityStream resource.
Properties
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
engineNativeAuditFieldsIncluded
↔ Output<
bool?> -
Specifies whether the database activity stream includes engine-native audit fields. This option only applies to an Oracle DB instance. By default, no engine-native audit fields are included. Defaults
false.latefinal - hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
- isProtected → bool
-
Returns whether this resource is protected from deletion.
no setterinherited
- isRemote → bool
-
Whether this resource is registered as remote.
no setterinherited
- isResourceReference → bool
-
Whether this instance represents a resource value returned over RPC.
finalinherited
-
kinesisStreamName
↔ Output<
String> -
The name of the Amazon Kinesis data stream to be used for the database activity stream.
latefinal
-
kmsKeyId
↔ Output<
String> -
The AWS KMS key identifier for encrypting messages in the database activity stream. The AWS KMS key identifier is the key ARN, key ID, alias ARN, or alias name for the KMS key.
latefinal
-
mode
↔ Output<
String> -
Specifies the mode of the database activity stream. Database events such as a change or access generate an activity stream event. The database session can handle these events either synchronously or asynchronously. One of:
sync,async.latefinal -
region
↔ Output<
String> -
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
-
resourceArn
↔ Output<
String> -
ARN of the DB cluster.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
- runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
urn
↔ Output<
String> -
latefinalinherited
Methods
-
failId(
Object error) → void -
Completes this resource ID with an error when registration fails.
inherited
-
failOutputs(
Object error) → void -
Completes all output properties with
error.inherited -
failUrn(
Object error) → void -
Completes this resource URN with an error when registration fails.
inherited
-
getProvider(
String moduleMember) → ProviderResource? -
Returns provider for
moduleMember's package, if configured.inherited -
getResourceName(
) → String -
Returns this resource's logical name.
inherited
-
getResourceType(
) → String -
Returns this resource's Pulumi type token.
inherited
-
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a nonexistent method or property is accessed.
inherited
-
registerOutput<
T> (String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output< T> -
Registers a dynamic output property for this resource.
inherited
-
resolveId(
String? value, {required bool isKnown}) → void -
Resolves the provider-assigned ID for this resource.
inherited
-
resolveOutputs(
Struct outputs) → void -
Resolves all output properties from a monitor response payload.
inherited
-
resolveUrn(
String value) → void -
Resolves this resource's URN once assigned by the engine.
inherited
-
serializeProperties(
Map< String, dynamic> properties) → Future<Struct> -
Serializes resource properties for RPC transmission.
inherited
-
toString(
) → String -
A string representation of this object.
inherited
Operators
-
operator ==(
Object other) → bool -
The equality operator.
inherited
Static Methods
-
get(
String name, Input< String> id, {ClusterActivityStreamState? state, CustomResourceOptions? options}) → ClusterActivityStream -
Gets an existing ClusterActivityStream resource's state with the given
nameandid.