digitalocean.SpacesBucketPolicy

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;

return await Deployment.RunAsync(() => 
{
    var foobarSpacesBucket = new DigitalOcean.SpacesBucket("foobarSpacesBucket", new()
    {
        Region = "nyc3",
    });

    var foobarSpacesBucketPolicy = new DigitalOcean.SpacesBucketPolicy("foobarSpacesBucketPolicy", new()
    {
        Region = foobarSpacesBucket.Region,
        Bucket = foobarSpacesBucket.Name,
        Policy = Output.Tuple(foobarSpacesBucket.Name, foobarSpacesBucket.Name).Apply(values =>
        {
            var foobarSpacesBucketName = values.Item1;
            var foobarSpacesBucketName1 = values.Item2;
            return JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["Version"] = "2012-10-17",
                ["Statement"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["Sid"] = "IPAllow",
                        ["Effect"] = "Deny",
                        ["Principal"] = "*",
                        ["Action"] = "s3:*",
                        ["Resource"] = new[]
                        {
                            $"arn:aws:s3:::{foobarSpacesBucketName}",
                            $"arn:aws:s3:::{foobarSpacesBucketName1}/*",
                        },
                        ["Condition"] = new Dictionary<string, object?>
                        {
                            ["NotIpAddress"] = new Dictionary<string, object?>
                            {
                                ["aws:SourceIp"] = "54.240.143.0/24",
                            },
                        },
                    },
                },
            });
        }),
    });

});

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobarSpacesBucket, err := digitalocean.NewSpacesBucket(ctx, "foobarSpacesBucket", &digitalocean.SpacesBucketArgs{
			Region: pulumi.String("nyc3"),
		})
		if err != nil {
			return err
		}
		_, err = digitalocean.NewSpacesBucketPolicy(ctx, "foobarSpacesBucketPolicy", &digitalocean.SpacesBucketPolicyArgs{
			Region: foobarSpacesBucket.Region,
			Bucket: foobarSpacesBucket.Name,
			Policy: pulumi.All(foobarSpacesBucket.Name, foobarSpacesBucket.Name).ApplyT(func(_args []interface{}) (string, error) {
				foobarSpacesBucketName := _args[0].(string)
				foobarSpacesBucketName1 := _args[1].(string)
				var _zero string
				tmpJSON0, err := json.Marshal(map[string]interface{}{
					"Version": "2012-10-17",
					"Statement": []map[string]interface{}{
						map[string]interface{}{
							"Sid":       "IPAllow",
							"Effect":    "Deny",
							"Principal": "*",
							"Action":    "s3:*",
							"Resource": []string{
								fmt.Sprintf("arn:aws:s3:::%v", foobarSpacesBucketName),
								fmt.Sprintf("arn:aws:s3:::%v/*", foobarSpacesBucketName1),
							},
							"Condition": map[string]interface{}{
								"NotIpAddress": map[string]interface{}{
									"aws:SourceIp": "54.240.143.0/24",
								},
							},
						},
					},
				})
				if err != nil {
					return _zero, err
				}
				json0 := string(tmpJSON0)
				return json0, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.SpacesBucket;
import com.pulumi.digitalocean.SpacesBucketArgs;
import com.pulumi.digitalocean.SpacesBucketPolicy;
import com.pulumi.digitalocean.SpacesBucketPolicyArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 foobarSpacesBucket = new SpacesBucket("foobarSpacesBucket", SpacesBucketArgs.builder()        
            .region("nyc3")
            .build());

        var foobarSpacesBucketPolicy = new SpacesBucketPolicy("foobarSpacesBucketPolicy", SpacesBucketPolicyArgs.builder()        
            .region(foobarSpacesBucket.region())
            .bucket(foobarSpacesBucket.name())
            .policy(Output.tuple(foobarSpacesBucket.name(), foobarSpacesBucket.name()).applyValue(values -> {
                var foobarSpacesBucketName = values.t1;
                var foobarSpacesBucketName1 = values.t2;
                return serializeJson(
                    jsonObject(
                        jsonProperty("Version", "2012-10-17"),
                        jsonProperty("Statement", jsonArray(jsonObject(
                            jsonProperty("Sid", "IPAllow"),
                            jsonProperty("Effect", "Deny"),
                            jsonProperty("Principal", "*"),
                            jsonProperty("Action", "s3:*"),
                            jsonProperty("Resource", jsonArray(
                                String.format("arn:aws:s3:::%s", foobarSpacesBucketName), 
                                String.format("arn:aws:s3:::%s/*", foobarSpacesBucketName1)
                            )),
                            jsonProperty("Condition", jsonObject(
                                jsonProperty("NotIpAddress", jsonObject(
                                    jsonProperty("aws:SourceIp", "54.240.143.0/24")
                                ))
                            ))
                        )))
                    ));
            }))
            .build());

    }
}

import pulumi
import json
import pulumi_digitalocean as digitalocean

foobar_spaces_bucket = digitalocean.SpacesBucket("foobarSpacesBucket", region="nyc3")
foobar_spaces_bucket_policy = digitalocean.SpacesBucketPolicy("foobarSpacesBucketPolicy",
    region=foobar_spaces_bucket.region,
    bucket=foobar_spaces_bucket.name,
    policy=pulumi.Output.all(foobar_spaces_bucket.name, foobar_spaces_bucket.name).apply(lambda foobarSpacesBucketName, foobarSpacesBucketName1: json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Sid": "IPAllow",
            "Effect": "Deny",
            "Principal": "*",
            "Action": "s3:*",
            "Resource": [
                f"arn:aws:s3:::{foobar_spaces_bucket_name}",
                f"arn:aws:s3:::{foobar_spaces_bucket_name1}/*",
            ],
            "Condition": {
                "NotIpAddress": {
                    "aws:SourceIp": "54.240.143.0/24",
                },
            },
        }],
    })))

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

const foobarSpacesBucket = new digitalocean.SpacesBucket("foobarSpacesBucket", {region: "nyc3"});
const foobarSpacesBucketPolicy = new digitalocean.SpacesBucketPolicy("foobarSpacesBucketPolicy", {
    region: foobarSpacesBucket.region,
    bucket: foobarSpacesBucket.name,
    policy: pulumi.all([foobarSpacesBucket.name, foobarSpacesBucket.name]).apply(([foobarSpacesBucketName, foobarSpacesBucketName1]) => JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Sid: "IPAllow",
            Effect: "Deny",
            Principal: "*",
            Action: "s3:*",
            Resource: [
                `arn:aws:s3:::${foobarSpacesBucketName}`,
                `arn:aws:s3:::${foobarSpacesBucketName1}/*`,
            ],
            Condition: {
                NotIpAddress: {
                    "aws:SourceIp": "54.240.143.0/24",
                },
            },
        }],
    })),
});

resources:
  foobarSpacesBucket:
    type: digitalocean:SpacesBucket
    properties:
      region: nyc3
  foobarSpacesBucketPolicy:
    type: digitalocean:SpacesBucketPolicy
    properties:
      region: ${foobarSpacesBucket.region}
      bucket: ${foobarSpacesBucket.name}
      policy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Sid: IPAllow
              Effect: Deny
              Principal: '*'
              Action: s3:*
              Resource:
                - arn:aws:s3:::${foobarSpacesBucket.name}
                - arn:aws:s3:::${foobarSpacesBucket.name}/*
              Condition:
                NotIpAddress:
                  aws:SourceIp: 54.240.143.0/24