aws.s3.getBucketNotification

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

const example = aws.s3.getBucketNotification({
    bucket: "example-bucket",
});

import pulumi
import pulumi_aws as aws

example = aws.s3.get_bucket_notification(bucket="example-bucket")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := s3.LookupBucketNotification(ctx, &s3.LookupBucketNotificationArgs{
			Bucket: "example-bucket",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = Aws.S3.GetBucketNotification.Invoke(new()
    {
        Bucket = "example-bucket",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.S3Functions;
import com.pulumi.aws.s3.inputs.GetBucketNotificationArgs;
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 = S3Functions.getBucketNotification(GetBucketNotificationArgs.builder()
            .bucket("example-bucket")
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: aws:s3:getBucketNotification
      arguments:
        bucket: example-bucket

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_s3_getbucketnotification" "example" {
  bucket = "example-bucket"
}

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

export = async () => {
    const shared = await aws.s3.getBucketNotification({
        bucket: "shared-bucket",
    });
    const s3ObjectCreated: aws.cloudwatch.EventRule[] = [];
    for (let range = 0; range < (shared.eventbridge ? 1 : 0); range++) {
        s3ObjectCreated.push(new aws.cloudwatch.EventRule(`s3_object_created-${range}`, {
            name: "shared-bucket-object-created",
            description: "S3 object-created events from the shared bucket.",
            eventPattern: JSON.stringify({
                source: ["aws.s3"],
                "detail-type": ["Object Created"],
                detail: {
                    bucket: {
                        name: [shared.bucket],
                    },
                },
            }),
        }));
    }
}

import pulumi
from typing import Any
import json
import pulumi_aws as aws

shared = aws.s3.get_bucket_notification(bucket="shared-bucket")
s3_object_created: list[aws.cloudwatch.EventRule] = []
for s3_object_created_range in [{"value": i} for i in range(0, 1 if shared.eventbridge else 0)]:
    s3_object_created.append(aws.cloudwatch.EventRule(f"s3_object_created-{s3_object_created_range['value']}",
        name="shared-bucket-object-created",
        description="S3 object-created events from the shared bucket.",
        event_pattern=json.dumps({
            "source": ["aws.s3"],
            "detail-type": ["Object Created"],
            "detail": {
                "bucket": {
                    "name": [shared.bucket],
                },
            },
        })))

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		shared, err := s3.LookupBucketNotification(ctx, &s3.LookupBucketNotificationArgs{
			Bucket: "shared-bucket",
		}, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"source": []string{
				"aws.s3",
			},
			"detail-type": []string{
				"Object Created",
			},
			"detail": map[string]interface{}{
				"bucket": map[string]interface{}{
					"name": []*string{
						shared.Bucket,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		var tmp0 int
		if pulumi.Bool(shared.Eventbridge) {
			tmp0 = 1
		} else {
			tmp0 = 0
		}
		var s3ObjectCreated []*cloudwatch.EventRule
		for index := 0; index < tmp0; index++ {
			key0 := index
			_ := index
			__res, err := cloudwatch.NewEventRule(ctx, fmt.Sprintf("s3_object_created-%v", key0), &cloudwatch.EventRuleArgs{
				Name:         pulumi.String("shared-bucket-object-created"),
				Description:  pulumi.String("S3 object-created events from the shared bucket."),
				EventPattern: json0,
			})
			if err != nil {
				return err
			}
			s3ObjectCreated = append(s3ObjectCreated, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(async() => 
{
    var shared = await Aws.S3.GetBucketNotification.InvokeAsync(new()
    {
        Bucket = "shared-bucket",
    });

    var s3ObjectCreated = new List<Aws.CloudWatch.EventRule>();
    for (var rangeIndex = 0; rangeIndex < shared.Eventbridge ? 1 : 0; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        s3ObjectCreated.Add(new Aws.CloudWatch.EventRule($"s3_object_created-{range.Value}", new()
        {
            Name = "shared-bucket-object-created",
            Description = "S3 object-created events from the shared bucket.",
            EventPattern = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["source"] = new[]
                {
                    "aws.s3",
                },
                ["detail-type"] = new[]
                {
                    "Object Created",
                },
                ["detail"] = new Dictionary<string, object?>
                {
                    ["bucket"] = new Dictionary<string, object?>
                    {
                        ["name"] = new[]
                        {
                            shared.Bucket,
                        },
                    },
                },
            }),
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.S3Functions;
import com.pulumi.aws.s3.inputs.GetBucketNotificationArgs;
import com.pulumi.aws.cloudwatch.EventRule;
import com.pulumi.aws.cloudwatch.EventRuleArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.codegen.internal.KeyedValue;
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 shared = S3Functions.getBucketNotification(GetBucketNotificationArgs.builder()
            .bucket("shared-bucket")
            .build());

        for (var i = 0; i < shared.eventbridge() ? 1 : 0; i++) {
            new EventRule("s3ObjectCreated-" + i, EventRuleArgs.builder()
                .name("shared-bucket-object-created")
                .description("S3 object-created events from the shared bucket.")
                .eventPattern(serializeJson(
                    jsonObject(
                        jsonProperty("source", jsonArray("aws.s3")),
                        jsonProperty("detail-type", jsonArray("Object Created")),
                        jsonProperty("detail", jsonObject(
                            jsonProperty("bucket", jsonObject(
                                jsonProperty("name", jsonArray(shared.bucket()))
                            ))
                        ))
                    )))
                .build());

        
}
    }
}

resources:
  s3ObjectCreated:
    type: aws:cloudwatch:EventRule
    name: s3_object_created
    properties:
      name: shared-bucket-object-created
      description: S3 object-created events from the shared bucket.
      eventPattern:
        fn::toJSON:
          source:
            - aws.s3
          detail-type:
            - Object Created
          detail:
            bucket:
              name:
                - ${shared.bucket}
    options: {}
variables:
  shared:
    fn::invoke:
      function: aws:s3:getBucketNotification
      arguments:
        bucket: shared-bucket

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_s3_getbucketnotification" "shared" {
  bucket = "shared-bucket"
}

resource "aws_cloudwatch_eventrule" "s3_object_created" {
  count       = data.aws_s3_getbucketnotification.shared.eventbridge ? 1 : 0
  name        = "shared-bucket-object-created"
  description = "S3 object-created events from the shared bucket."
  event_pattern = jsonencode({
    "source"      = ["aws.s3"]
    "detail-type" = ["Object Created"]
    "detail" = {
      "bucket" = {
        "name" = [data.aws_s3_getbucketnotification.shared.bucket]
      }
    }
  })
}

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

const existing = aws.s3.getBucketNotification({
    bucket: exampleAwsS3Bucket.id,
});
const example = new aws.s3.BucketNotification("example", {
    lambdaFunctions: .map(entry => ({
        id: entry.value.id,
        lambdaFunctionArn: entry.value.lambdaFunctionArn,
        events: entry.value.events,
        filterPrefix: entry.value.filterPrefix,
        filterSuffix: entry.value.filterSuffix,
    })),
    queues: .map(entry2 => ({
        id: entry2.value.id,
        queueArn: entry2.value.queueArn,
        events: entry2.value.events,
        filterPrefix: entry2.value.filterPrefix,
        filterSuffix: entry2.value.filterSuffix,
    })),
    topics: .map(entry3 => ({
        id: entry3.value.id,
        topicArn: entry3.value.topicArn,
        events: entry3.value.events,
        filterPrefix: entry3.value.filterPrefix,
        filterSuffix: entry3.value.filterSuffix,
    })),
    bucket: exampleAwsS3Bucket.id,
    eventbridge: existing.then(existing => existing.eventbridge),
});

import pulumi
import pulumi_aws as aws

existing = aws.s3.get_bucket_notification(bucket=example_aws_s3_bucket["id"])
example = aws.s3.BucketNotification("example",
    lambda_functions=[{"key": k, "value": v} for k, v in sorted(existing.lambda_functions.items())].apply(lambda entries: [aws.s3.BucketNotificationLambdaFunctionArgs(
        id=entry["value"].id,
        lambda_function_arn=entry["value"].lambda_function_arn,
        events=entry["value"].events,
        filter_prefix=entry["value"].filter_prefix,
        filter_suffix=entry["value"].filter_suffix,
    ) for entry in entries]),
    queues=[{"key": k, "value": v} for k, v in sorted(existing.queues.items())].apply(lambda entries: [aws.s3.BucketNotificationQueueArgs(
        id=entry2["value"].id,
        queue_arn=entry2["value"].queue_arn,
        events=entry2["value"].events,
        filter_prefix=entry2["value"].filter_prefix,
        filter_suffix=entry2["value"].filter_suffix,
    ) for entry2 in entries]),
    topics=[{"key": k, "value": v} for k, v in sorted(existing.topics.items())].apply(lambda entries: [aws.s3.BucketNotificationTopicArgs(
        id=entry3["value"].id,
        topic_arn=entry3["value"].topic_arn,
        events=entry3["value"].events,
        filter_prefix=entry3["value"].filter_prefix,
        filter_suffix=entry3["value"].filter_suffix,
    ) for entry3 in entries]),
    bucket=example_aws_s3_bucket["id"],
    eventbridge=existing.eventbridge)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var existing = Aws.S3.GetBucketNotification.Invoke(new()
    {
        Bucket = exampleAwsS3Bucket.Id,
    });

    var example = new Aws.S3.BucketNotification("example", new()
    {
        LambdaFunctions = ,
        Queues = ,
        Topics = ,
        Bucket = exampleAwsS3Bucket.Id,
        Eventbridge = existing.Apply(getBucketNotificationResult => getBucketNotificationResult.Eventbridge),
    });

});

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_s3_getbucketnotification" "existing" {
  bucket = exampleAwsS3Bucket.id
}

resource "aws_s3_bucketnotification" "example" {
  dynamic "lambda_functions" {
    for_each = entries(data.aws_s3_getbucketnotification.existing.lambda_functions)
    content {
      id                  = lambda_functions.value.value.id
      lambda_function_arn = lambda_functions.value.value.lambdaFunctionArn
      events              = lambda_functions.value.value.events
      filter_prefix       = lambda_functions.value.value.filterPrefix
      filter_suffix       = lambda_functions.value.value.filterSuffix
    }
  }
  dynamic "queues" {
    for_each = entries(data.aws_s3_getbucketnotification.existing.queues)
    content {
      id            = queues.value.value.id
      queue_arn     = queues.value.value.queueArn
      events        = queues.value.value.events
      filter_prefix = queues.value.value.filterPrefix
      filter_suffix = queues.value.value.filterSuffix
    }
  }
  dynamic "topics" {
    for_each = entries(data.aws_s3_getbucketnotification.existing.topics)
    content {
      id            = topics.value.value.id
      topic_arn     = topics.value.value.topicArn
      events        = topics.value.value.events
      filter_prefix = topics.value.value.filterPrefix
      filter_suffix = topics.value.value.filterSuffix
    }
  }
  bucket      = exampleAwsS3Bucket.id
  eventbridge = data.aws_s3_getbucketnotification.existing.eventbridge
}

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

const example = new aws.s3.BucketNotification("example", {
    lambdaFunctions: [{
        id: "my-team-rule",
        lambdaFunctionArn: mine.arn,
        events: ["s3:ObjectRemoved:*"],
    }],
    bucket: exampleAwsS3Bucket.id,
});

import pulumi
import pulumi_aws as aws

example = aws.s3.BucketNotification("example",
    lambda_functions=[{
        "id": "my-team-rule",
        "lambda_function_arn": mine["arn"],
        "events": ["s3:ObjectRemoved:*"],
    }],
    bucket=example_aws_s3_bucket["id"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := s3.NewBucketNotification(ctx, "example", &s3.BucketNotificationArgs{
			LambdaFunctions: s3.BucketNotificationLambdaFunctionArray{
				&s3.BucketNotificationLambdaFunctionArgs{
					Id:                pulumi.String("my-team-rule"),
					LambdaFunctionArn: pulumi.Any(mine.Arn),
					Events: pulumi.StringArray{
						pulumi.String("s3:ObjectRemoved:*"),
					},
				},
			},
			Bucket: pulumi.Any(exampleAwsS3Bucket.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.S3.BucketNotification("example", new()
    {
        LambdaFunctions = new[]
        {
            new Aws.S3.Inputs.BucketNotificationLambdaFunctionArgs
            {
                Id = "my-team-rule",
                LambdaFunctionArn = mine.Arn,
                Events = new[]
                {
                    "s3:ObjectRemoved:*",
                },
            },
        },
        Bucket = exampleAwsS3Bucket.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketNotification;
import com.pulumi.aws.s3.BucketNotificationArgs;
import com.pulumi.aws.s3.inputs.BucketNotificationLambdaFunctionArgs;
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 BucketNotification("example", BucketNotificationArgs.builder()
            .lambdaFunctions(BucketNotificationLambdaFunctionArgs.builder()
                .id("my-team-rule")
                .lambdaFunctionArn(mine.arn())
                .events("s3:ObjectRemoved:*")
                .build())
            .bucket(exampleAwsS3Bucket.id())
            .build());

    }
}

resources:
  example:
    type: aws:s3:BucketNotification
    properties:
      lambdaFunctions:
        - id: my-team-rule
          lambdaFunctionArn: ${mine.arn}
          events:
            - s3:ObjectRemoved:*
      bucket: ${exampleAwsS3Bucket.id}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_s3_bucketnotification" "example" {
  lambda_functions {
    id                  = "my-team-rule"
    lambda_function_arn = mine.arn
    events              = ["s3:ObjectRemoved:*"]
  }
  bucket = exampleAwsS3Bucket.id
}

function getBucketNotification(args: GetBucketNotificationArgs, opts?: InvokeOptions): Promise<GetBucketNotificationResult>
function getBucketNotificationOutput(args: GetBucketNotificationOutputArgs, opts?: InvokeOptions): Output<GetBucketNotificationResult>

def get_bucket_notification(bucket: Optional[str] = None,
                            region: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetBucketNotificationResult
def get_bucket_notification_output(bucket: pulumi.Input[Optional[str]] = None,
                            region: pulumi.Input[Optional[str]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetBucketNotificationResult]

func LookupBucketNotification(ctx *Context, args *LookupBucketNotificationArgs, opts ...InvokeOption) (*LookupBucketNotificationResult, error)
func LookupBucketNotificationOutput(ctx *Context, args *LookupBucketNotificationOutputArgs, opts ...InvokeOption) LookupBucketNotificationResultOutput

public static class GetBucketNotification 
{
    public static Task<GetBucketNotificationResult> InvokeAsync(GetBucketNotificationArgs args, InvokeOptions? opts = null)
    public static Output<GetBucketNotificationResult> Invoke(GetBucketNotificationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetBucketNotificationResult> getBucketNotification(GetBucketNotificationArgs args, InvokeOptions options)
public static Output<GetBucketNotificationResult> getBucketNotification(GetBucketNotificationArgs args, InvokeOptions options)

fn::invoke:
  function: aws:s3/getBucketNotification:getBucketNotification
  arguments:
    # arguments dictionary

data "aws_s3_getbucketnotification" "name" {
    # arguments
}