pulumi-aws-kotlin/com.pulumi.aws.rds.kotlin/EventSubscriptionArgs

EventSubscriptionArgs

data class EventSubscriptionArgs(val enabled: Output<Boolean>? = null, val eventCategories: Output<List<String>>? = null, val name: Output<String>? = null, val namePrefix: Output<String>? = null, val snsTopic: Output<String>? = null, val sourceIds: Output<List<String>>? = null, val sourceType: Output<String>? = null, val tags: Output<Map<String, String>>? = null) : ConvertibleToJava<EventSubscriptionArgs>

Provides a DB event subscription resource.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const _default = new aws.rds.Instance("default", {
    allocatedStorage: 10,
    engine: "mysql",
    engineVersion: "5.6.17",
    instanceClass: aws.rds.InstanceType.T2_Micro,
    dbName: "mydb",
    username: "foo",
    password: "bar",
    dbSubnetGroupName: "my_database_subnet_group",
    parameterGroupName: "default.mysql5.6",
});
const defaultTopic = new aws.sns.Topic("default", {name: "rds-events"});
const defaultEventSubscription = new aws.rds.EventSubscription("default", {
    name: "rds-event-sub",
    snsTopic: defaultTopic.arn,
    sourceType: "db-instance",
    sourceIds: [_default&#46;identifier],
    eventCategories: [
        "availability",
        "deletion",
        "failover",
        "failure",
        "low storage",
        "maintenance",
        "notification",
        "read replica",
        "recovery",
        "restoration",
    ],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
default = aws.rds.Instance("default",
    allocated_storage=10,
    engine="mysql",
    engine_version="5.6.17",
    instance_class=aws.rds.InstanceType.T2_MICRO,
    db_name="mydb",
    username="foo",
    password="bar",
    db_subnet_group_name="my_database_subnet_group",
    parameter_group_name="default.mysql5.6")
default_topic = aws.sns.Topic("default", name="rds-events")
default_event_subscription = aws.rds.EventSubscription("default",
    name="rds-event-sub",
    sns_topic=default_topic.arn,
    source_type="db-instance",
    source_ids=[default&#46;identifier],
    event_categories=[
        "availability",
        "deletion",
        "failover",
        "failure",
        "low storage",
        "maintenance",
        "notification",
        "read replica",
        "recovery",
        "restoration",
    ])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var @default = new Aws.Rds.Instance("default", new()
    {
        AllocatedStorage = 10,
        Engine = "mysql",
        EngineVersion = "5.6.17",
        InstanceClass = Aws.Rds.InstanceType.T2_Micro,
        DbName = "mydb",
        Username = "foo",
        Password = "bar",
        DbSubnetGroupName = "my_database_subnet_group",
        ParameterGroupName = "default.mysql5.6",
    });
    var defaultTopic = new Aws.Sns.Topic("default", new()
    {
        Name = "rds-events",
    });
    var defaultEventSubscription = new Aws.Rds.EventSubscription("default", new()
    {
        Name = "rds-event-sub",
        SnsTopic = defaultTopic.Arn,
        SourceType = "db-instance",
        SourceIds = new[]
        {
            @default.Identifier,
        },
        EventCategories = new[]
        {
            "availability",
            "deletion",
            "failover",
            "failure",
            "low storage",
            "maintenance",
            "notification",
            "read replica",
            "recovery",
            "restoration",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewInstance(ctx, "default", &rds.InstanceArgs{
			AllocatedStorage:   pulumi.Int(10),
			Engine:             pulumi.String("mysql"),
			EngineVersion:      pulumi.String("5.6.17"),
			InstanceClass:      pulumi.String(rds.InstanceType_T2_Micro),
			DbName:             pulumi.String("mydb"),
			Username:           pulumi.String("foo"),
			Password:           pulumi.String("bar"),
			DbSubnetGroupName:  pulumi.String("my_database_subnet_group"),
			ParameterGroupName: pulumi.String("default.mysql5.6"),
		})
		if err != nil {
			return err
		}
		defaultTopic, err := sns.NewTopic(ctx, "default", &sns.TopicArgs{
			Name: pulumi.String("rds-events"),
		})
		if err != nil {
			return err
		}
		_, err = rds.NewEventSubscription(ctx, "default", &rds.EventSubscriptionArgs{
			Name:       pulumi.String("rds-event-sub"),
			SnsTopic:   defaultTopic.Arn,
			SourceType: pulumi.String("db-instance"),
			SourceIds: pulumi.StringArray{
				_default.Identifier,
			},
			EventCategories: pulumi.StringArray{
				pulumi.String("availability"),
				pulumi.String("deletion"),
				pulumi.String("failover"),
				pulumi.String("failure"),
				pulumi.String("low storage"),
				pulumi.String("maintenance"),
				pulumi.String("notification"),
				pulumi.String("read replica"),
				pulumi.String("recovery"),
				pulumi.String("restoration"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.rds.Instance;
import com.pulumi.aws.rds.InstanceArgs;
import com.pulumi.aws.sns.Topic;
import com.pulumi.aws.sns.TopicArgs;
import com.pulumi.aws.rds.EventSubscription;
import com.pulumi.aws.rds.EventSubscriptionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var default_ = new Instance("default", InstanceArgs.builder()
            .allocatedStorage(10)
            .engine("mysql")
            .engineVersion("5.6.17")
            .instanceClass("db.t2.micro")
            .dbName("mydb")
            .username("foo")
            .password("bar")
            .dbSubnetGroupName("my_database_subnet_group")
            .parameterGroupName("default.mysql5.6")
            .build());
        var defaultTopic = new Topic("defaultTopic", TopicArgs.builder()
            .name("rds-events")
            .build());
        var defaultEventSubscription = new EventSubscription("defaultEventSubscription", EventSubscriptionArgs.builder()
            .name("rds-event-sub")
            .snsTopic(defaultTopic.arn())
            .sourceType("db-instance")
            .sourceIds(default_.identifier())
            .eventCategories(
                "availability",
                "deletion",
                "failover",
                "failure",
                "low storage",
                "maintenance",
                "notification",
                "read replica",
                "recovery",
                "restoration")
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: aws:rds:Instance
    properties:
      allocatedStorage: 10
      engine: mysql
      engineVersion: 5.6.17
      instanceClass: db.t2.micro
      dbName: mydb
      username: foo
      password: bar
      dbSubnetGroupName: my_database_subnet_group
      parameterGroupName: default.mysql5.6
  defaultTopic:
    type: aws:sns:Topic
    name: default
    properties:
      name: rds-events
  defaultEventSubscription:
    type: aws:rds:EventSubscription
    name: default
    properties:
      name: rds-event-sub
      snsTopic: ${defaultTopic.arn}
      sourceType: db-instance
      sourceIds:
        - ${default.identifier}
      eventCategories:
        - availability
        - deletion
        - failover
        - failure
        - low storage
        - maintenance
        - notification
        - read replica
        - recovery
        - restoration
Content copied to clipboard

Import

Using pulumi import, import DB Event Subscriptions using the name. For example:

$ pulumi import aws:rds/eventSubscription:EventSubscription default rds-event-sub
Content copied to clipboard

Constructors

Link copied to clipboard
fun EventSubscriptionArgs(enabled: Output<Boolean>? = null, eventCategories: Output<List<String>>? = null, name: Output<String>? = null, namePrefix: Output<String>? = null, snsTopic: Output<String>? = null, sourceIds: Output<List<String>>? = null, sourceType: Output<String>? = null, tags: Output<Map<String, String>>? = null)

Functions

Link copied to clipboard
open override fun toJava(): EventSubscriptionArgs

Properties

Link copied to clipboard
val enabled: Output<Boolean>? = null

A boolean flag to enable/disable the subscription. Defaults to true.

Link copied to clipboard
val eventCategories: Output<List<String>>? = null

A list of event categories for a SourceType that you want to subscribe to. See http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html or run aws rds describe-event-categories.

Link copied to clipboard
val name: Output<String>? = null

The name of the DB event subscription. By default generated by this provider.

Link copied to clipboard
val namePrefix: Output<String>? = null

The name of the DB event subscription. Conflicts with name.

Link copied to clipboard
val snsTopic: Output<String>? = null

The SNS topic to send events to.

Link copied to clipboard
val sourceIds: Output<List<String>>? = null

A list of identifiers of the event sources for which events will be returned. If not specified, then all sources are included in the response. If specified, a source_type must also be specified.

Link copied to clipboard
val sourceType: Output<String>? = null

The type of source that will be generating the events. Valid options are db-instance, db-security-group, db-parameter-group, db-snapshot, db-cluster, db-cluster-snapshot, or db-proxy. If not set, all sources will be subscribed to.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

A map of tags to assign to the resource. .If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.