IPSet

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var master = new Aws.GuardDuty.Detector("master", new Aws.GuardDuty.DetectorArgs
        {
            Enable = true,
        });
        var bucket = new Aws.S3.Bucket("bucket", new Aws.S3.BucketArgs
        {
            Acl = "private",
        });
        var myIPSetBucketObject = new Aws.S3.BucketObject("myIPSetBucketObject", new Aws.S3.BucketObjectArgs
        {
            Acl = "public-read",
            Bucket = bucket.Id,
            Content = @"10.0.0.0/8

",
            Key = "MyIPSet",
        });
        var myIPSetIPSet = new Aws.GuardDuty.IPSet("myIPSetIPSet", new Aws.GuardDuty.IPSetArgs
        {
            Activate = true,
            DetectorId = master.Id,
            Format = "TXT",
            Location = Output.Tuple(myIPSetBucketObject.Bucket, myIPSetBucketObject.Key).Apply(values =>
            {
                var bucket = values.Item1;
                var key = values.Item2;
                return $"https://s3.amazonaws.com/{bucket}/{key}";
            }),
        });
    }

}

package main

import (
    "fmt"

    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/guardduty"
    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/s3"
    "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        master, err := guardduty.NewDetector(ctx, "master", &guardduty.DetectorArgs{
            Enable: pulumi.Bool(true),
        })
        if err != nil {
            return err
        }
        bucket, err := s3.NewBucket(ctx, "bucket", &s3.BucketArgs{
            Acl: pulumi.String("private"),
        })
        if err != nil {
            return err
        }
        myIPSetBucketObject, err := s3.NewBucketObject(ctx, "myIPSetBucketObject", &s3.BucketObjectArgs{
            Acl:     pulumi.String("public-read"),
            Bucket:  bucket.ID(),
            Content: pulumi.String(fmt.Sprintf("%v%v", "10.0.0.0/8\n", "\n")),
            Key:     pulumi.String("MyIPSet"),
        })
        if err != nil {
            return err
        }
        _, err = guardduty.NewIPSet(ctx, "myIPSetIPSet", &guardduty.IPSetArgs{
            Activate:   pulumi.Bool(true),
            DetectorId: master.ID(),
            Format:     pulumi.String("TXT"),
            Location: pulumi.All(myIPSetBucketObject.Bucket, myIPSetBucketObject.Key).ApplyT(func(_args []interface{}) (string, error) {
                bucket := _args[0].(string)
                key := _args[1].(string)
                return fmt.Sprintf("%v%v%v%v", "https://s3.amazonaws.com/", bucket, "/", key), nil
            }).(pulumi.StringOutput),
        })
        if err != nil {
            return err
        }
        return nil
    })
}

import pulumi
import pulumi_aws as aws

master = aws.guardduty.Detector("master", enable=True)
bucket = aws.s3.Bucket("bucket", acl="private")
my_ip_set_bucket_object = aws.s3.BucketObject("myIPSetBucketObject",
    acl="public-read",
    bucket=bucket.id,
    content="""10.0.0.0/8

""",
    key="MyIPSet")
my_ip_set_ip_set = aws.guardduty.IPSet("myIPSetIPSet",
    activate=True,
    detector_id=master.id,
    format="TXT",
    location=pulumi.Output.all(my_ip_set_bucket_object.bucket, my_ip_set_bucket_object.key).apply(lambda bucket, key: f"https://s3.amazonaws.com/{bucket}/{key}"))

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

const master = new aws.guardduty.Detector("master", {
    enable: true,
});
const bucket = new aws.s3.Bucket("bucket", {
    acl: "private",
});
const myIPSetBucketObject = new aws.s3.BucketObject("MyIPSet", {
    acl: "public-read",
    bucket: bucket.id,
    content: "10.0.0.0/8\n",
    key: "MyIPSet",
});
const myIPSetIPSet = new aws.guardduty.IPSet("MyIPSet", {
    activate: true,
    detectorId: master.id,
    format: "TXT",
    location: pulumi.interpolate`https://s3.amazonaws.com/${myIPSetBucketObject.bucket}/${myIPSetBucketObject.key}`,
});