alicloud.oss.BucketReplication

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    var @default = new Random.RandomInteger("default", new()
    {
        Max = 99999,
        Min = 10000,
    });

    var bucketSrc = new AliCloud.Oss.Bucket("bucketSrc", new()
    {
        BucketName = @default.Result.Apply(result => $"example-src-{result}"),
    });

    var bucketDest = new AliCloud.Oss.Bucket("bucketDest", new()
    {
        BucketName = @default.Result.Apply(result => $"example-dest-{result}"),
    });

    var role = new AliCloud.Ram.Role("role", new()
    {
        Document = @"		{
		  ""Statement"": [
			{
			  ""Action"": ""sts:AssumeRole"",
			  ""Effect"": ""Allow"",
			  ""Principal"": {
				""Service"": [
				  ""oss.aliyuncs.com""
				]
			  }
			}
		  ],
		  ""Version"": ""1""
		}
",
        Description = "this is a test",
        Force = true,
    });

    var policy = new AliCloud.Ram.Policy("policy", new()
    {
        PolicyName = @default.Result.Apply(result => $"example-policy-{result}"),
        PolicyDocument = @"		{
		  ""Statement"": [
			{
			  ""Action"": [
				""*""
			  ],
			  ""Effect"": ""Allow"",
			  ""Resource"": [
				""*""
			  ]
			}
		  ],
			""Version"": ""1""
		}
",
        Description = "this is a policy test",
        Force = true,
    });

    var attach = new AliCloud.Ram.RolePolicyAttachment("attach", new()
    {
        PolicyName = policy.Name,
        PolicyType = policy.Type,
        RoleName = role.Name,
    });

    var key = new AliCloud.Kms.Key("key", new()
    {
        Description = "Hello KMS",
        PendingWindowInDays = 7,
        Status = "Enabled",
    });

    var cross_region_replication = new AliCloud.Oss.BucketReplication("cross-region-replication", new()
    {
        Bucket = bucketSrc.Id,
        Action = "PUT,DELETE",
        HistoricalObjectReplication = "enabled",
        PrefixSet = new AliCloud.Oss.Inputs.BucketReplicationPrefixSetArgs
        {
            Prefixes = new[]
            {
                "prefix1/",
                "prefix2/",
            },
        },
        Destination = new AliCloud.Oss.Inputs.BucketReplicationDestinationArgs
        {
            Bucket = bucketDest.Id,
            Location = bucketDest.Location,
        },
        SyncRole = role.Name,
        EncryptionConfiguration = new AliCloud.Oss.Inputs.BucketReplicationEncryptionConfigurationArgs
        {
            ReplicaKmsKeyId = key.Id,
        },
        SourceSelectionCriteria = new AliCloud.Oss.Inputs.BucketReplicationSourceSelectionCriteriaArgs
        {
            SseKmsEncryptedObjects = new AliCloud.Oss.Inputs.BucketReplicationSourceSelectionCriteriaSseKmsEncryptedObjectsArgs
            {
                Status = "Enabled",
            },
        },
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/kms"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/oss"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ram"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := random.NewRandomInteger(ctx, "default", &random.RandomIntegerArgs{
			Max: pulumi.Int(99999),
			Min: pulumi.Int(10000),
		})
		if err != nil {
			return err
		}
		bucketSrc, err := oss.NewBucket(ctx, "bucketSrc", &oss.BucketArgs{
			Bucket: _default.Result.ApplyT(func(result int) (string, error) {
				return fmt.Sprintf("example-src-%v", result), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		bucketDest, err := oss.NewBucket(ctx, "bucketDest", &oss.BucketArgs{
			Bucket: _default.Result.ApplyT(func(result int) (string, error) {
				return fmt.Sprintf("example-dest-%v", result), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		role, err := ram.NewRole(ctx, "role", &ram.RoleArgs{
			Document: pulumi.String(`		{
		  "Statement": [
			{
			  "Action": "sts:AssumeRole",
			  "Effect": "Allow",
			  "Principal": {
				"Service": [
				  "oss.aliyuncs.com"
				]
			  }
			}
		  ],
		  "Version": "1"
		}
`),
			Description: pulumi.String("this is a test"),
			Force:       pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		policy, err := ram.NewPolicy(ctx, "policy", &ram.PolicyArgs{
			PolicyName: _default.Result.ApplyT(func(result int) (string, error) {
				return fmt.Sprintf("example-policy-%v", result), nil
			}).(pulumi.StringOutput),
			PolicyDocument: pulumi.String(`		{
		  "Statement": [
			{
			  "Action": [
				"*"
			  ],
			  "Effect": "Allow",
			  "Resource": [
				"*"
			  ]
			}
		  ],
			"Version": "1"
		}
`),
			Description: pulumi.String("this is a policy test"),
			Force:       pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = ram.NewRolePolicyAttachment(ctx, "attach", &ram.RolePolicyAttachmentArgs{
			PolicyName: policy.Name,
			PolicyType: policy.Type,
			RoleName:   role.Name,
		})
		if err != nil {
			return err
		}
		key, err := kms.NewKey(ctx, "key", &kms.KeyArgs{
			Description:         pulumi.String("Hello KMS"),
			PendingWindowInDays: pulumi.Int(7),
			Status:              pulumi.String("Enabled"),
		})
		if err != nil {
			return err
		}
		_, err = oss.NewBucketReplication(ctx, "cross-region-replication", &oss.BucketReplicationArgs{
			Bucket:                      bucketSrc.ID(),
			Action:                      pulumi.String("PUT,DELETE"),
			HistoricalObjectReplication: pulumi.String("enabled"),
			PrefixSet: &oss.BucketReplicationPrefixSetArgs{
				Prefixes: pulumi.StringArray{
					pulumi.String("prefix1/"),
					pulumi.String("prefix2/"),
				},
			},
			Destination: &oss.BucketReplicationDestinationArgs{
				Bucket:   bucketDest.ID(),
				Location: bucketDest.Location,
			},
			SyncRole: role.Name,
			EncryptionConfiguration: &oss.BucketReplicationEncryptionConfigurationArgs{
				ReplicaKmsKeyId: key.ID(),
			},
			SourceSelectionCriteria: &oss.BucketReplicationSourceSelectionCriteriaArgs{
				SseKmsEncryptedObjects: &oss.BucketReplicationSourceSelectionCriteriaSseKmsEncryptedObjectsArgs{
					Status: pulumi.String("Enabled"),
				},
			},
		})
		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.random.RandomInteger;
import com.pulumi.random.RandomIntegerArgs;
import com.pulumi.alicloud.oss.Bucket;
import com.pulumi.alicloud.oss.BucketArgs;
import com.pulumi.alicloud.ram.Role;
import com.pulumi.alicloud.ram.RoleArgs;
import com.pulumi.alicloud.ram.Policy;
import com.pulumi.alicloud.ram.PolicyArgs;
import com.pulumi.alicloud.ram.RolePolicyAttachment;
import com.pulumi.alicloud.ram.RolePolicyAttachmentArgs;
import com.pulumi.alicloud.kms.Key;
import com.pulumi.alicloud.kms.KeyArgs;
import com.pulumi.alicloud.oss.BucketReplication;
import com.pulumi.alicloud.oss.BucketReplicationArgs;
import com.pulumi.alicloud.oss.inputs.BucketReplicationPrefixSetArgs;
import com.pulumi.alicloud.oss.inputs.BucketReplicationDestinationArgs;
import com.pulumi.alicloud.oss.inputs.BucketReplicationEncryptionConfigurationArgs;
import com.pulumi.alicloud.oss.inputs.BucketReplicationSourceSelectionCriteriaArgs;
import com.pulumi.alicloud.oss.inputs.BucketReplicationSourceSelectionCriteriaSseKmsEncryptedObjectsArgs;
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 default_ = new RandomInteger("default", RandomIntegerArgs.builder()        
            .max(99999)
            .min(10000)
            .build());

        var bucketSrc = new Bucket("bucketSrc", BucketArgs.builder()        
            .bucket(default_.result().applyValue(result -> String.format("example-src-%s", result)))
            .build());

        var bucketDest = new Bucket("bucketDest", BucketArgs.builder()        
            .bucket(default_.result().applyValue(result -> String.format("example-dest-%s", result)))
            .build());

        var role = new Role("role", RoleArgs.builder()        
            .document("""
		{
		  "Statement": [
			{
			  "Action": "sts:AssumeRole",
			  "Effect": "Allow",
			  "Principal": {
				"Service": [
				  "oss.aliyuncs.com"
				]
			  }
			}
		  ],
		  "Version": "1"
		}
            """)
            .description("this is a test")
            .force(true)
            .build());

        var policy = new Policy("policy", PolicyArgs.builder()        
            .policyName(default_.result().applyValue(result -> String.format("example-policy-%s", result)))
            .policyDocument("""
		{
		  "Statement": [
			{
			  "Action": [
				"*"
			  ],
			  "Effect": "Allow",
			  "Resource": [
				"*"
			  ]
			}
		  ],
			"Version": "1"
		}
            """)
            .description("this is a policy test")
            .force(true)
            .build());

        var attach = new RolePolicyAttachment("attach", RolePolicyAttachmentArgs.builder()        
            .policyName(policy.name())
            .policyType(policy.type())
            .roleName(role.name())
            .build());

        var key = new Key("key", KeyArgs.builder()        
            .description("Hello KMS")
            .pendingWindowInDays("7")
            .status("Enabled")
            .build());

        var cross_region_replication = new BucketReplication("cross-region-replication", BucketReplicationArgs.builder()        
            .bucket(bucketSrc.id())
            .action("PUT,DELETE")
            .historicalObjectReplication("enabled")
            .prefixSet(BucketReplicationPrefixSetArgs.builder()
                .prefixes(                
                    "prefix1/",
                    "prefix2/")
                .build())
            .destination(BucketReplicationDestinationArgs.builder()
                .bucket(bucketDest.id())
                .location(bucketDest.location())
                .build())
            .syncRole(role.name())
            .encryptionConfiguration(BucketReplicationEncryptionConfigurationArgs.builder()
                .replicaKmsKeyId(key.id())
                .build())
            .sourceSelectionCriteria(BucketReplicationSourceSelectionCriteriaArgs.builder()
                .sseKmsEncryptedObjects(BucketReplicationSourceSelectionCriteriaSseKmsEncryptedObjectsArgs.builder()
                    .status("Enabled")
                    .build())
                .build())
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random

default = random.RandomInteger("default",
    max=99999,
    min=10000)
bucket_src = alicloud.oss.Bucket("bucketSrc", bucket=default.result.apply(lambda result: f"example-src-{result}"))
bucket_dest = alicloud.oss.Bucket("bucketDest", bucket=default.result.apply(lambda result: f"example-dest-{result}"))
role = alicloud.ram.Role("role",
    document="""		{
		  "Statement": [
			{
			  "Action": "sts:AssumeRole",
			  "Effect": "Allow",
			  "Principal": {
				"Service": [
				  "oss.aliyuncs.com"
				]
			  }
			}
		  ],
		  "Version": "1"
		}
""",
    description="this is a test",
    force=True)
policy = alicloud.ram.Policy("policy",
    policy_name=default.result.apply(lambda result: f"example-policy-{result}"),
    policy_document="""		{
		  "Statement": [
			{
			  "Action": [
				"*"
			  ],
			  "Effect": "Allow",
			  "Resource": [
				"*"
			  ]
			}
		  ],
			"Version": "1"
		}
""",
    description="this is a policy test",
    force=True)
attach = alicloud.ram.RolePolicyAttachment("attach",
    policy_name=policy.name,
    policy_type=policy.type,
    role_name=role.name)
key = alicloud.kms.Key("key",
    description="Hello KMS",
    pending_window_in_days=7,
    status="Enabled")
cross_region_replication = alicloud.oss.BucketReplication("cross-region-replication",
    bucket=bucket_src.id,
    action="PUT,DELETE",
    historical_object_replication="enabled",
    prefix_set=alicloud.oss.BucketReplicationPrefixSetArgs(
        prefixes=[
            "prefix1/",
            "prefix2/",
        ],
    ),
    destination=alicloud.oss.BucketReplicationDestinationArgs(
        bucket=bucket_dest.id,
        location=bucket_dest.location,
    ),
    sync_role=role.name,
    encryption_configuration=alicloud.oss.BucketReplicationEncryptionConfigurationArgs(
        replica_kms_key_id=key.id,
    ),
    source_selection_criteria=alicloud.oss.BucketReplicationSourceSelectionCriteriaArgs(
        sse_kms_encrypted_objects=alicloud.oss.BucketReplicationSourceSelectionCriteriaSseKmsEncryptedObjectsArgs(
            status="Enabled",
        ),
    ))

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as random from "@pulumi/random";

const _default = new random.RandomInteger("default", {
    max: 99999,
    min: 10000,
});
const bucketSrc = new alicloud.oss.Bucket("bucketSrc", {bucket: pulumi.interpolate`example-src-${_default.result}`});
const bucketDest = new alicloud.oss.Bucket("bucketDest", {bucket: pulumi.interpolate`example-dest-${_default.result}`});
const role = new alicloud.ram.Role("role", {
    document: `		{
		  "Statement": [
			{
			  "Action": "sts:AssumeRole",
			  "Effect": "Allow",
			  "Principal": {
				"Service": [
				  "oss.aliyuncs.com"
				]
			  }
			}
		  ],
		  "Version": "1"
		}
`,
    description: "this is a test",
    force: true,
});
const policy = new alicloud.ram.Policy("policy", {
    policyName: pulumi.interpolate`example-policy-${_default.result}`,
    policyDocument: `		{
		  "Statement": [
			{
			  "Action": [
				"*"
			  ],
			  "Effect": "Allow",
			  "Resource": [
				"*"
			  ]
			}
		  ],
			"Version": "1"
		}
`,
    description: "this is a policy test",
    force: true,
});
const attach = new alicloud.ram.RolePolicyAttachment("attach", {
    policyName: policy.name,
    policyType: policy.type,
    roleName: role.name,
});
const key = new alicloud.kms.Key("key", {
    description: "Hello KMS",
    pendingWindowInDays: 7,
    status: "Enabled",
});
const cross_region_replication = new alicloud.oss.BucketReplication("cross-region-replication", {
    bucket: bucketSrc.id,
    action: "PUT,DELETE",
    historicalObjectReplication: "enabled",
    prefixSet: {
        prefixes: [
            "prefix1/",
            "prefix2/",
        ],
    },
    destination: {
        bucket: bucketDest.id,
        location: bucketDest.location,
    },
    syncRole: role.name,
    encryptionConfiguration: {
        replicaKmsKeyId: key.id,
    },
    sourceSelectionCriteria: {
        sseKmsEncryptedObjects: {
            status: "Enabled",
        },
    },
});

resources:
  default:
    type: random:RandomInteger
    properties:
      max: 99999
      min: 10000
  bucketSrc:
    type: alicloud:oss:Bucket
    properties:
      bucket: example-src-${default.result}
  bucketDest:
    type: alicloud:oss:Bucket
    properties:
      bucket: example-dest-${default.result}
  role:
    type: alicloud:ram:Role
    properties:
      document: |
        		{
        		  "Statement": [
        			{
        			  "Action": "sts:AssumeRole",
        			  "Effect": "Allow",
        			  "Principal": {
        				"Service": [
        				  "oss.aliyuncs.com"
        				]
        			  }
        			}
        		  ],
        		  "Version": "1"
        		}        
      description: this is a test
      force: true
  policy:
    type: alicloud:ram:Policy
    properties:
      policyName: example-policy-${default.result}
      policyDocument: |
        		{
        		  "Statement": [
        			{
        			  "Action": [
        				"*"
        			  ],
        			  "Effect": "Allow",
        			  "Resource": [
        				"*"
        			  ]
        			}
        		  ],
        			"Version": "1"
        		}        
      description: this is a policy test
      force: true
  attach:
    type: alicloud:ram:RolePolicyAttachment
    properties:
      policyName: ${policy.name}
      policyType: ${policy.type}
      roleName: ${role.name}
  key:
    type: alicloud:kms:Key
    properties:
      description: Hello KMS
      pendingWindowInDays: '7'
      status: Enabled
  cross-region-replication:
    type: alicloud:oss:BucketReplication
    properties:
      bucket: ${bucketSrc.id}
      action: PUT,DELETE
      historicalObjectReplication: enabled
      prefixSet:
        prefixes:
          - prefix1/
          - prefix2/
      destination:
        bucket: ${bucketDest.id}
        location: ${bucketDest.location}
      syncRole: ${role.name}
      encryptionConfiguration:
        replicaKmsKeyId: ${key.id}
      sourceSelectionCriteria:
        sseKmsEncryptedObjects:
          status: Enabled