CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/golang-github-com-pulumi-pulumi-aws-sdk-v7

A Pulumi provider SDK for creating and managing Amazon Web Services (AWS) cloud resources in Go, providing strongly-typed resource classes and data sources for all major AWS services.

Overview
Eval results
Files

sns-sqs.mddocs/reference/messaging/

Messaging: SNS, SQS, EventBridge, and Kinesis

This document covers the AWS messaging services available in the Pulumi AWS Go SDK, including Simple Notification Service (SNS), Simple Queue Service (SQS), EventBridge (formerly CloudWatch Events), and Kinesis.

Package Imports

import (
    "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
    "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sqs"
    "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch" // EventBridge resources
    "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/kinesis"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

SNS (Simple Notification Service)

Available Functions

// Resource constructors
NewDataProtectionPolicy(ctx, name, args, opts) (*DataProtectionPolicy, error)
NewPlatformApplication(ctx, name, args, opts) (*PlatformApplication, error)
NewSmsPreferences(ctx, name, args, opts) (*SmsPreferences, error)
NewTopic(ctx, name, args, opts) (*Topic, error)
NewTopicPolicy(ctx, name, args, opts) (*TopicPolicy, error)
NewTopicSubscription(ctx, name, args, opts) (*TopicSubscription, error)

// Data source lookups
GetDataProtectionPolicy(ctx, name, id, state, opts) (*DataProtectionPolicy, error)
GetPlatformApplication(ctx, name, id, state, opts) (*PlatformApplication, error)
GetSmsPreferences(ctx, name, id, state, opts) (*SmsPreferences, error)
GetTopic(ctx, name, id, state, opts) (*Topic, error)
GetTopicPolicy(ctx, name, id, state, opts) (*TopicPolicy, error)
GetTopicSubscription(ctx, name, id, state, opts) (*TopicSubscription, error)

sns.Topic

Provides an SNS topic resource. Supports standard and FIFO topics, server-side encryption, delivery policies, and message archiving.

Constructor

func NewTopic(ctx *pulumi.Context,
    name string, args *TopicArgs, opts ...pulumi.ResourceOption) (*Topic, error)

TopicArgs

type TopicArgs struct {
    // IAM role ARN for application endpoint failure feedback
    ApplicationFailureFeedbackRoleArn pulumi.StringPtrInput
    // IAM role ARN permitted to receive application endpoint success feedback
    ApplicationSuccessFeedbackRoleArn pulumi.StringPtrInput
    // Percentage (0-100) of successful application deliveries to sample
    ApplicationSuccessFeedbackSampleRate pulumi.IntPtrInput
    // Message archive policy for FIFO topics (JSON string)
    ArchivePolicy pulumi.StringPtrInput
    // Enable content-based deduplication for FIFO topics
    ContentBasedDeduplication pulumi.BoolPtrInput
    // SNS delivery policy JSON (retries, backoff, etc.)
    DeliveryPolicy pulumi.StringPtrInput
    // Display name for the topic (used for SMS subscriptions)
    DisplayName pulumi.StringPtrInput
    // FIFO throughput scope: "Topic" or "MessageGroup"
    FifoThroughputScope pulumi.StringPtrInput
    // Create a FIFO topic; name must end with ".fifo". Default: false
    FifoTopic pulumi.BoolPtrInput
    // IAM role ARN for Firehose endpoint failure feedback
    FirehoseFailureFeedbackRoleArn pulumi.StringPtrInput
    // IAM role ARN permitted to receive Firehose success feedback
    FirehoseSuccessFeedbackRoleArn pulumi.StringPtrInput
    // Percentage of successful Firehose deliveries to sample
    FirehoseSuccessFeedbackSampleRate pulumi.IntPtrInput
    // IAM role ARN for HTTP endpoint failure feedback
    HttpFailureFeedbackRoleArn pulumi.StringPtrInput
    // IAM role ARN permitted to receive HTTP success feedback
    HttpSuccessFeedbackRoleArn pulumi.StringPtrInput
    // Percentage of successful HTTP deliveries to sample
    HttpSuccessFeedbackSampleRate pulumi.IntPtrInput
    // KMS CMK ID or ARN for server-side encryption; use "alias/aws/sns" for AWS-managed key
    KmsMasterKeyId pulumi.StringPtrInput
    // IAM role ARN for Lambda endpoint failure feedback
    LambdaFailureFeedbackRoleArn pulumi.StringPtrInput
    // IAM role ARN permitted to receive Lambda success feedback
    LambdaSuccessFeedbackRoleArn pulumi.StringPtrInput
    // Percentage of successful Lambda deliveries to sample
    LambdaSuccessFeedbackSampleRate pulumi.IntPtrInput
    // Topic name (1-256 chars; FIFO must end with ".fifo"). Conflicts with NamePrefix
    Name pulumi.StringPtrInput
    // Unique name prefix. Conflicts with Name
    NamePrefix pulumi.StringPtrInput
    // Fully-formed IAM policy document JSON
    Policy pulumi.StringPtrInput
    // AWS region override
    Region pulumi.StringPtrInput
    // Signature version: 1 (SHA1) or 2 (SHA256)
    SignatureVersion pulumi.IntPtrInput
    // IAM role ARN for SQS endpoint failure feedback
    SqsFailureFeedbackRoleArn pulumi.StringPtrInput
    // IAM role ARN permitted to receive SQS success feedback
    SqsSuccessFeedbackRoleArn pulumi.StringPtrInput
    // Percentage of successful SQS deliveries to sample
    SqsSuccessFeedbackSampleRate pulumi.IntPtrInput
    // Resource tags
    Tags pulumi.StringMapInput
    // X-Ray tracing mode: "PassThrough" or "Active"
    TracingConfig pulumi.StringPtrInput
}

Topic Output Fields

type Topic struct {
    pulumi.CustomResourceState

    ApplicationFailureFeedbackRoleArn    pulumi.StringPtrOutput
    ApplicationSuccessFeedbackRoleArn    pulumi.StringPtrOutput
    ApplicationSuccessFeedbackSampleRate pulumi.IntPtrOutput
    ArchivePolicy                        pulumi.StringPtrOutput
    Arn                                  pulumi.StringOutput    // ARN of the SNS topic
    BeginningArchiveTime                 pulumi.StringOutput
    ContentBasedDeduplication            pulumi.BoolPtrOutput
    DeliveryPolicy                       pulumi.StringPtrOutput
    DisplayName                          pulumi.StringPtrOutput
    FifoThroughputScope                  pulumi.StringOutput
    FifoTopic                            pulumi.BoolPtrOutput
    FirehoseFailureFeedbackRoleArn       pulumi.StringPtrOutput
    FirehoseSuccessFeedbackRoleArn       pulumi.StringPtrOutput
    FirehoseSuccessFeedbackSampleRate    pulumi.IntPtrOutput
    HttpFailureFeedbackRoleArn           pulumi.StringPtrOutput
    HttpSuccessFeedbackRoleArn           pulumi.StringPtrOutput
    HttpSuccessFeedbackSampleRate        pulumi.IntPtrOutput
    KmsMasterKeyId                       pulumi.StringPtrOutput
    LambdaFailureFeedbackRoleArn         pulumi.StringPtrOutput
    LambdaSuccessFeedbackRoleArn         pulumi.StringPtrOutput
    LambdaSuccessFeedbackSampleRate      pulumi.IntPtrOutput
    Name                                 pulumi.StringOutput
    NamePrefix                           pulumi.StringOutput
    Owner                                pulumi.StringOutput    // AWS Account ID of the topic owner
    Policy                               pulumi.StringOutput
    Region                               pulumi.StringOutput
    SignatureVersion                      pulumi.IntOutput
    SqsFailureFeedbackRoleArn            pulumi.StringPtrOutput
    SqsSuccessFeedbackRoleArn            pulumi.StringPtrOutput
    SqsSuccessFeedbackSampleRate         pulumi.IntPtrOutput
    Tags                                 pulumi.StringMapOutput
    TagsAll                              pulumi.StringMapOutput
    TracingConfig                        pulumi.StringOutput
}

Lookup

func GetTopic(ctx *pulumi.Context,
    name string, id pulumi.IDInput, state *TopicState,
    opts ...pulumi.ResourceOption) (*Topic, error)

The GetTopicArgs for the data source lookup:

// Use sns.LookupTopic / sns.LookupTopicOutput for data source queries:
// Required: TopicArn string

Example: Basic Topic

topic, err := sns.NewTopic(ctx, "userUpdates", &sns.TopicArgs{
    Name: pulumi.String("user-updates-topic"),
    Tags: pulumi.StringMap{
        "Environment": pulumi.String("production"),
    },
})

Example: Encrypted FIFO Topic

fifoTopic, err := sns.NewTopic(ctx, "orderEvents", &sns.TopicArgs{
    Name:                      pulumi.String("order-events.fifo"),
    FifoTopic:                 pulumi.Bool(true),
    ContentBasedDeduplication: pulumi.Bool(true),
    KmsMasterKeyId:            pulumi.String("alias/aws/sns"),
})

sns.TopicSubscription

Subscribes an endpoint to an SNS topic. Supports SQS, Lambda, HTTP/HTTPS, email, SMS, and Kinesis Firehose protocols.

Constructor

func NewTopicSubscription(ctx *pulumi.Context,
    name string, args *TopicSubscriptionArgs,
    opts ...pulumi.ResourceOption) (*TopicSubscription, error)

TopicSubscriptionArgs

type TopicSubscriptionArgs struct {
    // Minutes to wait for subscription confirmation (HTTP/HTTPS only). Default: 1
    ConfirmationTimeoutInMinutes pulumi.IntPtrInput
    // Delivery policy JSON (HTTP/HTTPS only)
    DeliveryPolicy pulumi.StringPtrInput
    // Endpoint to send data to (ARN, URL, email address, phone number, etc.)
    Endpoint pulumi.StringInput
    // Whether the endpoint can auto-confirm the subscription. Default: false
    EndpointAutoConfirms pulumi.BoolPtrInput
    // JSON filter policy to selectively receive messages
    FilterPolicy pulumi.StringPtrInput
    // Apply filter policy to "MessageAttributes" (default) or "MessageBody"
    FilterPolicyScope pulumi.StringPtrInput
    // Protocol: "sqs", "sms", "lambda", "firehose", "application",
    //           "email", "email-json", "http", "https"
    Protocol pulumi.StringInput
    // Enable raw message delivery (pass message directly, not wrapped in JSON). Default: false
    RawMessageDelivery pulumi.BoolPtrInput
    // Dead letter queue redrive policy JSON
    RedrivePolicy pulumi.StringPtrInput
    // AWS region override
    Region pulumi.StringPtrInput
    // Archived message replay policy JSON
    ReplayPolicy pulumi.StringPtrInput
    // IAM role ARN for publishing to Kinesis Firehose
    SubscriptionRoleArn pulumi.StringPtrInput
    // ARN of the SNS topic to subscribe to (required)
    Topic pulumi.StringInput
}

TopicSubscription Output Fields

type TopicSubscription struct {
    pulumi.CustomResourceState

    Arn                          pulumi.StringOutput  // ARN of the subscription
    ConfirmationTimeoutInMinutes pulumi.IntPtrOutput
    ConfirmationWasAuthenticated pulumi.BoolOutput
    DeliveryPolicy               pulumi.StringPtrOutput
    Endpoint                     pulumi.StringOutput
    EndpointAutoConfirms         pulumi.BoolPtrOutput
    FilterPolicy                 pulumi.StringPtrOutput
    FilterPolicyScope            pulumi.StringOutput
    OwnerId                      pulumi.StringOutput
    PendingConfirmation          pulumi.BoolOutput
    Protocol                     pulumi.StringOutput
    RawMessageDelivery           pulumi.BoolPtrOutput
    RedrivePolicy                pulumi.StringPtrOutput
    Region                       pulumi.StringOutput
    ReplayPolicy                 pulumi.StringPtrOutput
    SubscriptionRoleArn          pulumi.StringPtrOutput
    Topic                        pulumi.StringOutput
}

Example: SNS to SQS Subscription

topic, _ := sns.NewTopic(ctx, "updates", &sns.TopicArgs{
    Name: pulumi.String("user-updates-topic"),
})

queue, _ := sqs.NewQueue(ctx, "updatesQueue", &sqs.QueueArgs{
    Name: pulumi.String("user-updates-queue"),
})

_, err := sns.NewTopicSubscription(ctx, "sqsSubscription", &sns.TopicSubscriptionArgs{
    Topic:    topic.Arn,
    Protocol: pulumi.String("sqs"),
    Endpoint: queue.Arn,
})

SQS (Simple Queue Service)

Available Functions

// Resource constructors
NewQueue(ctx, name, args, opts) (*Queue, error)
NewQueuePolicy(ctx, name, args, opts) (*QueuePolicy, error)
NewRedriveAllowPolicy(ctx, name, args, opts) (*RedriveAllowPolicy, error)
NewRedrivePolicy(ctx, name, args, opts) (*RedrivePolicy, error)

// Data source lookups
GetQueue(ctx, name, id, state, opts) (*Queue, error)
GetQueuePolicy(ctx, name, id, state, opts) (*QueuePolicy, error)
GetQueues(ctx, args, opts) (*GetQueuesResult, error)
GetRedriveAllowPolicy(ctx, name, id, state, opts) (*RedriveAllowPolicy, error)
GetRedrivePolicy(ctx, name, id, state, opts) (*RedrivePolicy, error)

sqs.Queue

Provides a fully managed SQS queue resource. Supports standard and FIFO queues, encryption, dead-letter queues, and long polling.

Warning: AWS will hang indefinitely when creating or updating an sqs.Queue with an associated sqs.QueuePolicy if Version = "2012-10-17" is not explicitly set in the policy.

Constructor

func NewQueue(ctx *pulumi.Context,
    name string, args *QueueArgs, opts ...pulumi.ResourceOption) (*Queue, error)

QueueArgs

type QueueArgs struct {
    // Enable content-based deduplication for FIFO queues
    ContentBasedDeduplication pulumi.BoolPtrInput
    // Deduplication scope: "messageGroup" or "queue" (default)
    DeduplicationScope pulumi.StringPtrInput
    // Delay in seconds before messages are available (0-900). Default: 0
    DelaySeconds pulumi.IntPtrInput
    // Create a FIFO queue; name must end with ".fifo". Default: false
    FifoQueue pulumi.BoolPtrInput
    // FIFO throughput limit: "perQueue" (default) or "perMessageGroupId"
    FifoThroughputLimit pulumi.StringPtrInput
    // Seconds SQS can reuse a KMS data key before calling KMS again (60-86400). Default: 300
    KmsDataKeyReusePeriodSeconds pulumi.IntPtrInput
    // KMS CMK ID for server-side encryption
    KmsMasterKeyId pulumi.StringPtrInput
    // Max message size in bytes (1024-1048576). Default: 262144 (256 KiB)
    MaxMessageSize pulumi.IntPtrInput
    // Message retention period in seconds (60-1209600). Default: 345600 (4 days)
    MessageRetentionSeconds pulumi.IntPtrInput
    // Queue name (1-80 chars; FIFO must end with ".fifo"). Conflicts with NamePrefix
    Name pulumi.StringPtrInput
    // Unique name prefix. Conflicts with Name
    NamePrefix pulumi.StringPtrInput
    // IAM policy JSON. Prefer sqs.QueuePolicy resource instead
    Policy pulumi.StringPtrInput
    // Long polling wait time in seconds (0-20). Default: 0 (short polling)
    ReceiveWaitTimeSeconds pulumi.IntPtrInput
    // Dead letter queue redrive allow policy JSON. Prefer sqs.RedriveAllowPolicy resource
    RedriveAllowPolicy pulumi.StringPtrInput
    // Dead letter queue redrive policy JSON. Prefer sqs.RedrivePolicy resource
    RedrivePolicy pulumi.StringPtrInput
    // AWS region override
    Region pulumi.StringPtrInput
    // Enable SQS-owned SSE encryption. Default: false
    SqsManagedSseEnabled pulumi.BoolPtrInput
    // Resource tags
    Tags pulumi.StringMapInput
    // Visibility timeout in seconds (0-43200). Default: 30
    VisibilityTimeoutSeconds pulumi.IntPtrInput
}

Queue Output Fields

type Queue struct {
    pulumi.CustomResourceState

    Arn                          pulumi.StringOutput    // ARN of the SQS queue
    ContentBasedDeduplication    pulumi.BoolPtrOutput
    DeduplicationScope           pulumi.StringOutput
    DelaySeconds                 pulumi.IntPtrOutput
    FifoQueue                    pulumi.BoolPtrOutput
    FifoThroughputLimit          pulumi.StringOutput
    KmsDataKeyReusePeriodSeconds pulumi.IntOutput
    KmsMasterKeyId               pulumi.StringPtrOutput
    MaxMessageSize               pulumi.IntPtrOutput
    MessageRetentionSeconds      pulumi.IntPtrOutput
    Name                         pulumi.StringOutput
    NamePrefix                   pulumi.StringOutput
    Policy                       pulumi.StringOutput
    ReceiveWaitTimeSeconds       pulumi.IntPtrOutput
    RedriveAllowPolicy           pulumi.StringOutput
    RedrivePolicy                pulumi.StringOutput
    Region                       pulumi.StringOutput
    SqsManagedSseEnabled         pulumi.BoolOutput
    Tags                         pulumi.StringMapOutput
    TagsAll                      pulumi.StringMapOutput
    Url                          pulumi.StringOutput    // Queue URL (same as ID)
    VisibilityTimeoutSeconds     pulumi.IntPtrOutput
}

Lookup

func GetQueue(ctx *pulumi.Context,
    name string, id pulumi.IDInput, state *QueueState,
    opts ...pulumi.ResourceOption) (*Queue, error)

For data source lookup by name, use sqs.LookupQueue with GetQueueArgs:

type GetQueueArgs struct {
    // Name of the queue to look up (required)
    Name string
    // Optional resource tags filter
    Tags map[string]string
}

Example: Standard Queue with Dead Letter Queue

import "encoding/json"

dlq, _ := sqs.NewQueue(ctx, "deadLetterQueue", &sqs.QueueArgs{
    Name:                    pulumi.String("my-app-dlq"),
    MessageRetentionSeconds: pulumi.Int(1209600), // 14 days
})

redriveJSON, _ := json.Marshal(map[string]interface{}{
    "deadLetterTargetArn": dlq.Arn,
    "maxReceiveCount":     4,
})

queue, err := sqs.NewQueue(ctx, "mainQueue", &sqs.QueueArgs{
    Name:                    pulumi.String("my-app-queue"),
    DelaySeconds:            pulumi.Int(0),
    MaxMessageSize:          pulumi.Int(262144),
    MessageRetentionSeconds: pulumi.Int(86400),
    ReceiveWaitTimeSeconds:  pulumi.Int(20), // long polling
    VisibilityTimeoutSeconds: pulumi.Int(30),
    RedrivePolicy:           pulumi.String(string(redriveJSON)),
    Tags: pulumi.StringMap{
        "Environment": pulumi.String("production"),
    },
})

Example: FIFO Queue with High Throughput

_, err := sqs.NewQueue(ctx, "orderQueue", &sqs.QueueArgs{
    Name:                      pulumi.String("orders.fifo"),
    FifoQueue:                 pulumi.Bool(true),
    ContentBasedDeduplication: pulumi.Bool(true),
    DeduplicationScope:        pulumi.String("messageGroup"),
    FifoThroughputLimit:       pulumi.String("perMessageGroupId"),
})

Example: Encrypted Queue (KMS)

_, err := sqs.NewQueue(ctx, "secureQueue", &sqs.QueueArgs{
    Name:                         pulumi.String("secure-queue"),
    KmsMasterKeyId:               pulumi.String("alias/aws/sqs"),
    KmsDataKeyReusePeriodSeconds: pulumi.Int(300),
})

sqs.QueuePolicy

Attaches an IAM policy to an SQS queue. Use this resource to grant other services (such as SNS) permission to send messages to the queue.

Warning: Always include "Version": "2012-10-17" in the policy document to prevent AWS from hanging on create/update.

Constructor

func NewQueuePolicy(ctx *pulumi.Context,
    name string, args *QueuePolicyArgs, opts ...pulumi.ResourceOption) (*QueuePolicy, error)

QueuePolicyArgs

type QueuePolicyArgs struct {
    // IAM policy JSON document (must include Version: "2012-10-17")
    Policy pulumi.StringInput
    // URL of the SQS queue to attach the policy to (required)
    QueueUrl pulumi.StringInput
    // AWS region override
    Region pulumi.StringPtrInput
}

QueuePolicy Output Fields

type QueuePolicy struct {
    pulumi.CustomResourceState

    Policy   pulumi.StringOutput
    QueueUrl pulumi.StringOutput
    Region   pulumi.StringOutput
}

Example: SNS to SQS Queue Policy

import "encoding/json"

queue, _ := sqs.NewQueue(ctx, "myQueue", &sqs.QueueArgs{
    Name: pulumi.String("my-queue"),
})

_, err := sqs.NewQueuePolicy(ctx, "myQueuePolicy", &sqs.QueuePolicyArgs{
    QueueUrl: queue.ID(),
    Policy: pulumi.All(queue.Arn, snsTopic.Arn).ApplyT(func(args []interface{}) (string, error) {
        queueArn := args[0].(string)
        topicArn := args[1].(string)
        policy, _ := json.Marshal(map[string]interface{}{
            "Version": "2012-10-17",
            "Statement": []map[string]interface{}{
                {
                    "Sid":    "AllowSNS",
                    "Effect": "Allow",
                    "Principal": map[string]interface{}{
                        "Service": "sns.amazonaws.com",
                    },
                    "Action":   "SQS:SendMessage",
                    "Resource": queueArn,
                    "Condition": map[string]interface{}{
                        "ArnEquals": map[string]interface{}{
                            "aws:SourceArn": topicArn,
                        },
                    },
                },
            },
        })
        return string(policy), nil
    }).(pulumi.StringOutput),
})

EventBridge (formerly CloudWatch Events)

EventBridge resources live in the cloudwatch package. EventBridge was formerly known as CloudWatch Events; the functionality is identical.

Available EventBridge Functions

// Resource constructors
NewEventApiDestination(ctx, name, args, opts) (*EventApiDestination, error)
NewEventArchive(ctx, name, args, opts) (*EventArchive, error)
NewEventBus(ctx, name, args, opts) (*EventBus, error)
NewEventBusPolicy(ctx, name, args, opts) (*EventBusPolicy, error)
NewEventConnection(ctx, name, args, opts) (*EventConnection, error)
NewEventEndpoint(ctx, name, args, opts) (*EventEndpoint, error)
NewEventPermission(ctx, name, args, opts) (*EventPermission, error)
NewEventRule(ctx, name, args, opts) (*EventRule, error)
NewEventTarget(ctx, name, args, opts) (*EventTarget, error)

// Data source lookups
GetEventApiDestination(ctx, name, id, state, opts) (*EventApiDestination, error)
GetEventArchive(ctx, name, id, state, opts) (*EventArchive, error)
GetEventBus(ctx, name, id, state, opts) (*EventBus, error)
GetEventBusPolicy(ctx, name, id, state, opts) (*EventBusPolicy, error)
GetEventConnection(ctx, name, id, state, opts) (*EventConnection, error)
GetEventEndpoint(ctx, name, id, state, opts) (*EventEndpoint, error)
GetEventPermission(ctx, name, id, state, opts) (*EventPermission, error)
GetEventRule(ctx, name, id, state, opts) (*EventRule, error)
GetEventSource(ctx, args, opts) (*GetEventSourceResult, error)
GetEventTarget(ctx, name, id, state, opts) (*EventTarget, error)

cloudwatch.EventRule

Defines an EventBridge rule that triggers on a schedule or event pattern.

Constructor

func NewEventRule(ctx *pulumi.Context,
    name string, args *EventRuleArgs, opts ...pulumi.ResourceOption) (*EventRule, error)

EventRuleArgs

type EventRuleArgs struct {
    // Description of the rule
    Description pulumi.StringPtrInput
    // Name or ARN of the event bus. Default: "default"
    EventBusName pulumi.StringPtrInput
    // Event pattern JSON. Required if ScheduleExpression is not set
    EventPattern pulumi.StringPtrInput
    // Delete managed rules created by AWS. Default: false
    ForceDestroy pulumi.BoolPtrInput
    // Deprecated: Use State instead
    IsEnabled pulumi.BoolPtrInput
    // Rule name. Conflicts with NamePrefix
    Name pulumi.StringPtrInput
    // Unique name prefix (max 38 chars). Conflicts with Name
    NamePrefix pulumi.StringPtrInput
    // AWS region override
    Region pulumi.StringPtrInput
    // IAM role ARN used for target invocation
    RoleArn pulumi.StringPtrInput
    // Cron or rate expression, e.g. "rate(5 minutes)". Required if EventPattern is not set
    ScheduleExpression pulumi.StringPtrInput
    // Rule state: "DISABLED", "ENABLED", or "ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS"
    State pulumi.StringPtrInput
    // Resource tags
    Tags pulumi.StringMapInput
}

EventRule Output Fields

type EventRule struct {
    pulumi.CustomResourceState

    Arn                pulumi.StringOutput    // ARN of the rule
    Description        pulumi.StringPtrOutput
    EventBusName       pulumi.StringPtrOutput
    EventPattern       pulumi.StringPtrOutput
    ForceDestroy       pulumi.BoolPtrOutput
    IsEnabled          pulumi.BoolPtrOutput   // Deprecated
    Name               pulumi.StringOutput
    NamePrefix         pulumi.StringOutput
    Region             pulumi.StringOutput
    RoleArn            pulumi.StringPtrOutput
    ScheduleExpression pulumi.StringPtrOutput
    State              pulumi.StringPtrOutput
    Tags               pulumi.StringMapOutput
    TagsAll            pulumi.StringMapOutput
}

cloudwatch.EventTarget

Configures a target for an EventBridge rule. Supports Lambda, SQS, SNS, ECS, Step Functions, API Gateway, Batch, and more.

Constructor

func NewEventTarget(ctx *pulumi.Context,
    name string, args *EventTargetArgs, opts ...pulumi.ResourceOption) (*EventTarget, error)

EventTargetArgs (key fields)

type EventTargetArgs struct {
    // ARN of the target resource (required)
    Arn pulumi.StringInput
    // AppSync GraphQL API target configuration
    AppsyncTarget EventTargetAppsyncTargetPtrInput
    // AWS Batch job target configuration
    BatchTarget EventTargetBatchTargetPtrInput
    // Dead letter queue configuration
    DeadLetterConfig EventTargetDeadLetterConfigPtrInput
    // ECS task target configuration
    EcsTarget EventTargetEcsTargetPtrInput
    // Name or ARN of the event bus. Default: "default"
    EventBusName pulumi.StringPtrInput
    // Delete managed rules created by AWS. Default: false
    ForceDestroy pulumi.BoolPtrInput
    // API Gateway target configuration
    HttpTarget EventTargetHttpTargetPtrInput
    // JSON input passed directly to the target
    Input pulumi.StringPtrInput
    // JSONPath expression to extract part of the event
    InputPath pulumi.StringPtrInput
    // Input transformer configuration
    InputTransformer EventTargetInputTransformerPtrInput
    // Kinesis stream target configuration
    KinesisTarget EventTargetKinesisTargetPtrInput
    // AWS region override
    Region pulumi.StringPtrInput
    // Retry policy configuration
    RetryPolicy EventTargetRetryPolicyPtrInput
    // Name of the EventBridge rule (required)
    Rule pulumi.StringInput
    // IAM role ARN to use when sending events to the target
    RoleArn pulumi.StringPtrInput
    // Run Command target configuration
    RunCommandTargets EventTargetRunCommandTargetArrayInput
    // SageMaker pipeline target configuration
    SagemakerPipelineTarget EventTargetSagemakerPipelineTargetPtrInput
    // SQS FIFO queue message group ID
    SqsTarget EventTargetSqsTargetPtrInput
    // Target ID (unique within the rule). Default: random
    TargetId pulumi.StringPtrInput
}

Example: Scheduled Lambda Invocation

import "encoding/json"

rule, _ := cloudwatch.NewEventRule(ctx, "dailyCleanup", &cloudwatch.EventRuleArgs{
    Name:               pulumi.String("daily-cleanup"),
    Description:        pulumi.String("Trigger daily cleanup Lambda"),
    ScheduleExpression: pulumi.String("cron(0 2 * * ? *)"),
})

_, err := cloudwatch.NewEventTarget(ctx, "cleanupTarget", &cloudwatch.EventTargetArgs{
    Rule:     rule.Name,
    TargetId: pulumi.String("CleanupLambda"),
    Arn:      cleanupLambda.Arn,
})

Example: Event Pattern Rule (CloudTrail Sign-In)

patternJSON, _ := json.Marshal(map[string]interface{}{
    "detail-type": []string{"AWS Console Sign In via CloudTrail"},
})

rule, _ := cloudwatch.NewEventRule(ctx, "signInRule", &cloudwatch.EventRuleArgs{
    Name:         pulumi.String("capture-aws-sign-in"),
    Description:  pulumi.String("Capture each AWS Console Sign In"),
    EventPattern: pulumi.String(string(patternJSON)),
})

_, err := cloudwatch.NewEventTarget(ctx, "signInTarget", &cloudwatch.EventTargetArgs{
    Rule:     rule.Name,
    TargetId: pulumi.String("SendToSNS"),
    Arn:      notificationTopic.Arn,
})

Kinesis

Available Functions

// Resource constructors
NewAnalyticsApplication(ctx, name, args, opts) (*AnalyticsApplication, error)
NewFirehoseDeliveryStream(ctx, name, args, opts) (*FirehoseDeliveryStream, error)
NewResourcePolicy(ctx, name, args, opts) (*ResourcePolicy, error)
NewStream(ctx, name, args, opts) (*Stream, error)
NewStreamConsumer(ctx, name, args, opts) (*StreamConsumer, error)
NewVideoStream(ctx, name, args, opts) (*VideoStream, error)

// Data source lookups
GetAnalyticsApplication(ctx, name, id, state, opts) (*AnalyticsApplication, error)
GetFirehoseDeliveryStream(ctx, name, id, state, opts) (*FirehoseDeliveryStream, error)
GetResourcePolicy(ctx, name, id, state, opts) (*ResourcePolicy, error)
GetStream(ctx, name, id, state, opts) (*Stream, error)
GetStreamConsumer(ctx, name, id, state, opts) (*StreamConsumer, error)
GetVideoStream(ctx, name, id, state, opts) (*VideoStream, error)

kinesis.Stream

Provides a Kinesis Data Stream resource for real-time streaming data ingestion. Supports PROVISIONED and ON_DEMAND capacity modes.

Constructor

func NewStream(ctx *pulumi.Context,
    name string, args *StreamArgs, opts ...pulumi.ResourceOption) (*Stream, error)

StreamArgs

type StreamArgs struct {
    // Encryption type: "NONE" or "KMS". Default: "NONE"
    EncryptionType pulumi.StringPtrInput
    // Deregister all consumers before destroy. Default: false
    EnforceConsumerDeletion pulumi.BoolPtrInput
    // KMS key GUID or alias (e.g. "alias/aws/kinesis") for encryption
    KmsKeyId pulumi.StringPtrInput
    // Max single data record size in KiB (1024-10240)
    MaxRecordSizeInKib pulumi.IntPtrInput
    // Unique stream name within the AWS account and region
    Name pulumi.StringPtrInput
    // AWS region override
    Region pulumi.StringPtrInput
    // Data retention period in hours (24-8760). Default: 24
    RetentionPeriod pulumi.IntPtrInput
    // Number of shards (required for PROVISIONED mode)
    ShardCount pulumi.IntPtrInput
    // Shard-level CloudWatch metrics to enable (e.g. "IncomingBytes", "OutgoingBytes")
    ShardLevelMetrics pulumi.StringArrayInput
    // Stream capacity mode: PROVISIONED or ON_DEMAND
    StreamModeDetails StreamStreamModeDetailsPtrInput
    // Resource tags
    Tags pulumi.StringMapInput
}

Stream Output Fields

type Stream struct {
    pulumi.CustomResourceState

    Arn                     pulumi.StringOutput          // ARN of the Kinesis stream
    EncryptionType          pulumi.StringPtrOutput
    EnforceConsumerDeletion pulumi.BoolPtrOutput
    KmsKeyId                pulumi.StringPtrOutput
    MaxRecordSizeInKib      pulumi.IntOutput
    Name                    pulumi.StringOutput
    Region                  pulumi.StringOutput
    RetentionPeriod         pulumi.IntPtrOutput
    ShardCount              pulumi.IntPtrOutput
    ShardLevelMetrics       pulumi.StringArrayOutput
    StreamModeDetails       StreamStreamModeDetailsOutput
    Tags                    pulumi.StringMapOutput
    TagsAll                 pulumi.StringMapOutput
}

Example: Provisioned Kinesis Stream

stream, err := kinesis.NewStream(ctx, "appStream", &kinesis.StreamArgs{
    Name:            pulumi.String("my-app-stream"),
    ShardCount:      pulumi.Int(2),
    RetentionPeriod: pulumi.Int(48),
    ShardLevelMetrics: pulumi.StringArray{
        pulumi.String("IncomingBytes"),
        pulumi.String("OutgoingBytes"),
        pulumi.String("IteratorAgeMilliseconds"),
    },
    StreamModeDetails: &kinesis.StreamStreamModeDetailsArgs{
        StreamMode: pulumi.String("PROVISIONED"),
    },
    Tags: pulumi.StringMap{
        "Environment": pulumi.String("production"),
    },
})

Example: On-Demand Stream with Encryption

stream, err := kinesis.NewStream(ctx, "secureStream", &kinesis.StreamArgs{
    Name:           pulumi.String("secure-events"),
    EncryptionType: pulumi.String("KMS"),
    KmsKeyId:       pulumi.String("alias/aws/kinesis"),
    StreamModeDetails: &kinesis.StreamStreamModeDetailsArgs{
        StreamMode: pulumi.String("ON_DEMAND"),
    },
})

kinesis.FirehoseDeliveryStream

Delivers real-time streaming data to destinations such as S3, Redshift, OpenSearch, Splunk, HTTP endpoints, and Snowflake.

Constructor

func NewFirehoseDeliveryStream(ctx *pulumi.Context,
    name string, args *FirehoseDeliveryStreamArgs,
    opts ...pulumi.ResourceOption) (*FirehoseDeliveryStream, error)

FirehoseDeliveryStream Output Fields (key)

type FirehoseDeliveryStream struct {
    pulumi.CustomResourceState

    Arn                                pulumi.StringOutput  // ARN of the delivery stream
    // Destination type: "s3", "extendedS3", "redshift", "elasticsearch",
    //                   "splunk", "httpEndpoint", "opensearch",
    //                   "opensearchserverless", "snowflake"
    Destination                        pulumi.StringOutput
    DestinationId                      pulumi.StringOutput
    ElasticsearchConfiguration         FirehoseDeliveryStreamElasticsearchConfigurationPtrOutput
    ExtendedS3Configuration            FirehoseDeliveryStreamExtendedS3ConfigurationPtrOutput
    HttpEndpointConfiguration          FirehoseDeliveryStreamHttpEndpointConfigurationPtrOutput
    IcebergConfiguration               FirehoseDeliveryStreamIcebergConfigurationPtrOutput
    // Source: Kinesis Data Stream
    KinesisSourceConfiguration         FirehoseDeliveryStreamKinesisSourceConfigurationPtrOutput
    MskSourceConfiguration             FirehoseDeliveryStreamMskSourceConfigurationPtrOutput
    Name                               pulumi.StringOutput
    OpensearchConfiguration            FirehoseDeliveryStreamOpensearchConfigurationPtrOutput
    OpensearchserverlessConfiguration  FirehoseDeliveryStreamOpensearchserverlessConfigurationPtrOutput
    RedshiftConfiguration              FirehoseDeliveryStreamRedshiftConfigurationPtrOutput
    Region                             pulumi.StringOutput
    ServerSideEncryption               FirehoseDeliveryStreamServerSideEncryptionPtrOutput
    SnowflakeConfiguration             FirehoseDeliveryStreamSnowflakeConfigurationPtrOutput
    SplunkConfiguration                FirehoseDeliveryStreamSplunkConfigurationPtrOutput
    Tags                               pulumi.StringMapOutput
    TagsAll                            pulumi.StringMapOutput
    VersionId                          pulumi.StringOutput
}

Note: Server-side encryption should not be enabled when a Kinesis Data Stream is configured as the source.

Note: For WAF logging, the stream name must be prefixed with aws-waf-logs-.

Example: Firehose to S3

deliveryStream, err := kinesis.NewFirehoseDeliveryStream(ctx, "logsToS3", &kinesis.FirehoseDeliveryStreamArgs{
    Name:        pulumi.String("app-logs-to-s3"),
    Destination: pulumi.String("extendedS3"),
    ExtendedS3Configuration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs{
        RoleArn:   firehoseRole.Arn,
        BucketArn: logsBucket.Arn,
        BufferingSize: pulumi.Int(128),
        BufferingInterval: pulumi.Int(300),
        CompressionFormat: pulumi.String("GZIP"),
    },
})

Common Pattern: SNS Fan-Out to Multiple SQS Queues

// Create the SNS topic
topic, _ := sns.NewTopic(ctx, "events", &sns.TopicArgs{
    Name: pulumi.String("application-events"),
})

// Create multiple SQS queues
for _, service := range []string{"billing", "inventory", "notifications"} {
    queue, _ := sqs.NewQueue(ctx, service+"Queue", &sqs.QueueArgs{
        Name: pulumi.String(service + "-events-queue"),
    })

    // Subscribe each queue to the topic
    sns.NewTopicSubscription(ctx, service+"Subscription", &sns.TopicSubscriptionArgs{
        Topic:    topic.Arn,
        Protocol: pulumi.String("sqs"),
        Endpoint: queue.Arn,
    })
}

Install with Tessl CLI

npx tessl i tessl/golang-github-com-pulumi-pulumi-aws-sdk-v7

docs

reference

messaging

sns-sqs.md

core-data-sources.md

provider.md

index.md

tile.json