EventSubscription class

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const _default = new aws.neptune.Cluster("default", {
    clusterIdentifier: "neptune-cluster-demo",
    engine: "neptune",
    backupRetentionPeriod: 5,
    preferredBackupWindow: "07:00-09:00",
    skipFinalSnapshot: true,
    iamDatabaseAuthenticationEnabled: true,
    applyImmediately: true,
});
const example = new aws.neptune.ClusterInstance("example", {
    clusterIdentifier: _default.id,
    engine: "neptune",
    instanceClass: "db.r4.large",
    applyImmediately: true,
});
const defaultTopic = new aws.sns.Topic("default", {name: "neptune-events"});
const defaultEventSubscription = new aws.neptune.EventSubscription("default", {
    name: "neptune-event-sub",
    snsTopicArn: defaultTopic.arn,
    sourceType: "db-instance",
    sourceIds: [example.id],
    eventCategories: [
        "maintenance",
        "availability",
        "creation",
        "backup",
        "restoration",
        "recovery",
        "deletion",
        "failover",
        "failure",
        "notification",
        "configuration change",
        "read replica",
    ],
    tags: {
        env: "test",
    },
});
import pulumi
import pulumi_aws as aws

default = aws.neptune.Cluster("default",
    cluster_identifier="neptune-cluster-demo",
    engine="neptune",
    backup_retention_period=5,
    preferred_backup_window="07:00-09:00",
    skip_final_snapshot=True,
    iam_database_authentication_enabled=True,
    apply_immediately=True)
example = aws.neptune.ClusterInstance("example",
    cluster_identifier=default.id,
    engine="neptune",
    instance_class="db.r4.large",
    apply_immediately=True)
default_topic = aws.sns.Topic("default", name="neptune-events")
default_event_subscription = aws.neptune.EventSubscription("default",
    name="neptune-event-sub",
    sns_topic_arn=default_topic.arn,
    source_type="db-instance",
    source_ids=[example.id],
    event_categories=[
        "maintenance",
        "availability",
        "creation",
        "backup",
        "restoration",
        "recovery",
        "deletion",
        "failover",
        "failure",
        "notification",
        "configuration change",
        "read replica",
    ],
    tags={
        "env": "test",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var @default = new Aws.Neptune.Cluster("default", new()
    {
        ClusterIdentifier = "neptune-cluster-demo",
        Engine = "neptune",
        BackupRetentionPeriod = 5,
        PreferredBackupWindow = "07:00-09:00",
        SkipFinalSnapshot = true,
        IamDatabaseAuthenticationEnabled = true,
        ApplyImmediately = true,
    });

    var example = new Aws.Neptune.ClusterInstance("example", new()
    {
        ClusterIdentifier = @default.Id,
        Engine = "neptune",
        InstanceClass = "db.r4.large",
        ApplyImmediately = true,
    });

    var defaultTopic = new Aws.Sns.Topic("default", new()
    {
        Name = "neptune-events",
    });

    var defaultEventSubscription = new Aws.Neptune.EventSubscription("default", new()
    {
        Name = "neptune-event-sub",
        SnsTopicArn = defaultTopic.Arn,
        SourceType = "db-instance",
        SourceIds = new[]
        {
            example.Id,
        },
        EventCategories = new[]
        {
            "maintenance",
            "availability",
            "creation",
            "backup",
            "restoration",
            "recovery",
            "deletion",
            "failover",
            "failure",
            "notification",
            "configuration change",
            "read replica",
        },
        Tags =
        {
            { "env", "test" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/neptune"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := neptune.NewCluster(ctx, "default", &neptune.ClusterArgs{
			ClusterIdentifier:                pulumi.String("neptune-cluster-demo"),
			Engine:                           pulumi.String("neptune"),
			BackupRetentionPeriod:            pulumi.Int(5),
			PreferredBackupWindow:            pulumi.String("07:00-09:00"),
			SkipFinalSnapshot:                pulumi.Bool(true),
			IamDatabaseAuthenticationEnabled: pulumi.Bool(true),
			ApplyImmediately:                 pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		example, err := neptune.NewClusterInstance(ctx, "example", &neptune.ClusterInstanceArgs{
			ClusterIdentifier: _default.ID().ToIDOutput().ToStringOutput(),
			Engine:            pulumi.String("neptune"),
			InstanceClass:     pulumi.String("db.r4.large"),
			ApplyImmediately:  pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		defaultTopic, err := sns.NewTopic(ctx, "default", &sns.TopicArgs{
			Name: pulumi.String("neptune-events"),
		})
		if err != nil {
			return err
		}
		_, err = neptune.NewEventSubscription(ctx, "default", &neptune.EventSubscriptionArgs{
			Name:        pulumi.String("neptune-event-sub"),
			SnsTopicArn: defaultTopic.Arn,
			SourceType:  pulumi.String("db-instance"),
			SourceIds: pulumi.StringArray{
				example.ID().ToIDOutput().ToStringOutput(),
			},
			EventCategories: pulumi.StringArray{
				pulumi.String("maintenance"),
				pulumi.String("availability"),
				pulumi.String("creation"),
				pulumi.String("backup"),
				pulumi.String("restoration"),
				pulumi.String("recovery"),
				pulumi.String("deletion"),
				pulumi.String("failover"),
				pulumi.String("failure"),
				pulumi.String("notification"),
				pulumi.String("configuration change"),
				pulumi.String("read replica"),
			},
			Tags: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_neptune_cluster" "default" {
  cluster_identifier                  = "neptune-cluster-demo"
  engine                              = "neptune"
  backup_retention_period             = 5
  preferred_backup_window             = "07:00-09:00"
  skip_final_snapshot                 = true
  iam_database_authentication_enabled = "true"
  apply_immediately                   = "true"
}
resource "aws_neptune_clusterinstance" "example" {
  cluster_identifier = aws_neptune_cluster.default.id
  engine             = "neptune"
  instance_class     = "db.r4.large"
  apply_immediately  = "true"
}
resource "aws_sns_topic" "default" {
  name = "neptune-events"
}
resource "aws_neptune_eventsubscription" "default" {
  name             = "neptune-event-sub"
  sns_topic_arn    = aws_sns_topic.default.arn
  source_type      = "db-instance"
  source_ids       = [aws_neptune_clusterinstance.example.id]
  event_categories = ["maintenance", "availability", "creation", "backup", "restoration", "recovery", "deletion", "failover", "failure", "notification", "configuration change", "read replica"]
  tags = {
    "env" = "test"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.neptune.Cluster;
import com.pulumi.aws.neptune.ClusterArgs;
import com.pulumi.aws.neptune.ClusterInstance;
import com.pulumi.aws.neptune.ClusterInstanceArgs;
import com.pulumi.aws.sns.Topic;
import com.pulumi.aws.sns.TopicArgs;
import com.pulumi.aws.neptune.EventSubscription;
import com.pulumi.aws.neptune.EventSubscriptionArgs;
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("neptune-cluster-demo")
            .engine("neptune")
            .backupRetentionPeriod(5)
            .preferredBackupWindow("07:00-09:00")
            .skipFinalSnapshot(true)
            .iamDatabaseAuthenticationEnabled(true)
            .applyImmediately(true)
            .build());

        var example = new ClusterInstance("example", ClusterInstanceArgs.builder()
            .clusterIdentifier(default_.id())
            .engine("neptune")
            .instanceClass("db.r4.large")
            .applyImmediately(true)
            .build());

        var defaultTopic = new Topic("defaultTopic", TopicArgs.builder()
            .name("neptune-events")
            .build());

        var defaultEventSubscription = new EventSubscription("defaultEventSubscription", EventSubscriptionArgs.builder()
            .name("neptune-event-sub")
            .snsTopicArn(defaultTopic.arn())
            .sourceType("db-instance")
            .sourceIds(example.id())
            .eventCategories(
                "maintenance",
                "availability",
                "creation",
                "backup",
                "restoration",
                "recovery",
                "deletion",
                "failover",
                "failure",
                "notification",
                "configuration change",
                "read replica")
            .tags(Map.of("env", "test"))
            .build());

    }
}
resources:
  default:
    type: aws:neptune:Cluster
    properties:
      clusterIdentifier: neptune-cluster-demo
      engine: neptune
      backupRetentionPeriod: 5
      preferredBackupWindow: 07:00-09:00
      skipFinalSnapshot: true
      iamDatabaseAuthenticationEnabled: 'true'
      applyImmediately: 'true'
  example:
    type: aws:neptune:ClusterInstance
    properties:
      clusterIdentifier: ${default.id}
      engine: neptune
      instanceClass: db.r4.large
      applyImmediately: 'true'
  defaultTopic:
    type: aws:sns:Topic
    name: default
    properties:
      name: neptune-events
  defaultEventSubscription:
    type: aws:neptune:EventSubscription
    name: default
    properties:
      name: neptune-event-sub
      snsTopicArn: ${defaultTopic.arn}
      sourceType: db-instance
      sourceIds:
        - ${example.id}
      eventCategories:
        - maintenance
        - availability
        - creation
        - backup
        - restoration
        - recovery
        - deletion
        - failover
        - failure
        - notification
        - configuration change
        - read replica
      tags:
        env: test

Import

Using pulumi import, import aws.neptune.EventSubscription using the event subscription name. For example:

$ pulumi import aws:neptune/eventSubscription:EventSubscription example my-event-subscription

Constructors

EventSubscription(String name, {EventSubscriptionArgs? args, CustomResourceOptions? options})
Creates a new EventSubscription. name The Pulumi resource name. args Arguments used to configure this EventSubscription. The set of arguments for EventSubscription. options Resource options controlling this resource's behavior.
EventSubscription.reference(String urn)
Creates a typed reference to an existing EventSubscription resource.

Properties

arn ↔ Output<String>
ARN of the Neptune event notification subscription.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
customerAwsId ↔ Output<String>
The AWS customer account associated with the Neptune event notification subscription.
latefinal
enabled ↔ Output<bool?>
A boolean flag to enable/disable the subscription. Defaults to true.
latefinal
eventCategories ↔ Output<List<String>?>
A list of event categories for a sourceType that you want to subscribe to. Run aws neptune describe-event-categories to find all the event categories.
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
name ↔ Output<String>
The name of the Neptune event subscription. By default generated by this provider.
latefinal
namePrefix ↔ Output<String>
The name of the Neptune event subscription. Conflicts with name.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
snsTopicArn ↔ Output<String>
The ARN of the SNS topic to send events to.
latefinal
sourceIds ↔ Output<List<String>?>
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 sourceType must also be specified.
latefinal
sourceType ↔ Output<String?>
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 or db-cluster-snapshot. If not set, all sources will be subscribed to.
latefinal
tags ↔ Output<Map<String, String>?>
A map of tags to assign to the resource. .If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
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, {EventSubscriptionState? state, CustomResourceOptions? options}) → EventSubscription
Gets an existing EventSubscription resource's state with the given name and id.