azure.storage.ObjectReplication

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var srcResourceGroup = new Azure.Core.ResourceGroup("srcResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var srcAccount = new Azure.Storage.Account("srcAccount", new Azure.Storage.AccountArgs
        {
            ResourceGroupName = srcResourceGroup.Name,
            Location = srcResourceGroup.Location,
            AccountTier = "Standard",
            AccountReplicationType = "LRS",
            BlobProperties = new Azure.Storage.Inputs.AccountBlobPropertiesArgs
            {
                VersioningEnabled = true,
                ChangeFeedEnabled = true,
            },
        });
        var srcContainer = new Azure.Storage.Container("srcContainer", new Azure.Storage.ContainerArgs
        {
            StorageAccountName = srcAccount.Name,
            ContainerAccessType = "private",
        });
        var dstResourceGroup = new Azure.Core.ResourceGroup("dstResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "East US",
        });
        var dstAccount = new Azure.Storage.Account("dstAccount", new Azure.Storage.AccountArgs
        {
            ResourceGroupName = dstResourceGroup.Name,
            Location = dstResourceGroup.Location,
            AccountTier = "Standard",
            AccountReplicationType = "LRS",
            BlobProperties = new Azure.Storage.Inputs.AccountBlobPropertiesArgs
            {
                VersioningEnabled = true,
                ChangeFeedEnabled = true,
            },
        });
        var dstContainer = new Azure.Storage.Container("dstContainer", new Azure.Storage.ContainerArgs
        {
            StorageAccountName = dstAccount.Name,
            ContainerAccessType = "private",
        });
        var example = new Azure.Storage.ObjectReplication("example", new Azure.Storage.ObjectReplicationArgs
        {
            SourceStorageAccountId = srcAccount.Id,
            DestinationStorageAccountId = dstAccount.Id,
            Rules = 
            {
                new Azure.Storage.Inputs.ObjectReplicationRuleArgs
                {
                    SourceContainerName = srcContainer.Name,
                    DestinationContainerName = dstContainer.Name,
                },
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		srcResourceGroup, err := core.NewResourceGroup(ctx, "srcResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		srcAccount, err := storage.NewAccount(ctx, "srcAccount", &storage.AccountArgs{
			ResourceGroupName:      srcResourceGroup.Name,
			Location:               srcResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
			BlobProperties: &storage.AccountBlobPropertiesArgs{
				VersioningEnabled: pulumi.Bool(true),
				ChangeFeedEnabled: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		srcContainer, err := storage.NewContainer(ctx, "srcContainer", &storage.ContainerArgs{
			StorageAccountName:  srcAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		dstResourceGroup, err := core.NewResourceGroup(ctx, "dstResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("East US"),
		})
		if err != nil {
			return err
		}
		dstAccount, err := storage.NewAccount(ctx, "dstAccount", &storage.AccountArgs{
			ResourceGroupName:      dstResourceGroup.Name,
			Location:               dstResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
			BlobProperties: &storage.AccountBlobPropertiesArgs{
				VersioningEnabled: pulumi.Bool(true),
				ChangeFeedEnabled: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		dstContainer, err := storage.NewContainer(ctx, "dstContainer", &storage.ContainerArgs{
			StorageAccountName:  dstAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewObjectReplication(ctx, "example", &storage.ObjectReplicationArgs{
			SourceStorageAccountId:      srcAccount.ID(),
			DestinationStorageAccountId: dstAccount.ID(),
			Rules: storage.ObjectReplicationRuleArray{
				&storage.ObjectReplicationRuleArgs{
					SourceContainerName:      srcContainer.Name,
					DestinationContainerName: dstContainer.Name,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

const srcResourceGroup = new azure.core.ResourceGroup("srcResourceGroup", {location: "West Europe"});
const srcAccount = new azure.storage.Account("srcAccount", {
    resourceGroupName: srcResourceGroup.name,
    location: srcResourceGroup.location,
    accountTier: "Standard",
    accountReplicationType: "LRS",
    blobProperties: {
        versioningEnabled: true,
        changeFeedEnabled: true,
    },
});
const srcContainer = new azure.storage.Container("srcContainer", {
    storageAccountName: srcAccount.name,
    containerAccessType: "private",
});
const dstResourceGroup = new azure.core.ResourceGroup("dstResourceGroup", {location: "East US"});
const dstAccount = new azure.storage.Account("dstAccount", {
    resourceGroupName: dstResourceGroup.name,
    location: dstResourceGroup.location,
    accountTier: "Standard",
    accountReplicationType: "LRS",
    blobProperties: {
        versioningEnabled: true,
        changeFeedEnabled: true,
    },
});
const dstContainer = new azure.storage.Container("dstContainer", {
    storageAccountName: dstAccount.name,
    containerAccessType: "private",
});
const example = new azure.storage.ObjectReplication("example", {
    sourceStorageAccountId: srcAccount.id,
    destinationStorageAccountId: dstAccount.id,
    rules: [{
        sourceContainerName: srcContainer.name,
        destinationContainerName: dstContainer.name,
    }],
});

import pulumi
import pulumi_azure as azure

src_resource_group = azure.core.ResourceGroup("srcResourceGroup", location="West Europe")
src_account = azure.storage.Account("srcAccount",
    resource_group_name=src_resource_group.name,
    location=src_resource_group.location,
    account_tier="Standard",
    account_replication_type="LRS",
    blob_properties=azure.storage.AccountBlobPropertiesArgs(
        versioning_enabled=True,
        change_feed_enabled=True,
    ))
src_container = azure.storage.Container("srcContainer",
    storage_account_name=src_account.name,
    container_access_type="private")
dst_resource_group = azure.core.ResourceGroup("dstResourceGroup", location="East US")
dst_account = azure.storage.Account("dstAccount",
    resource_group_name=dst_resource_group.name,
    location=dst_resource_group.location,
    account_tier="Standard",
    account_replication_type="LRS",
    blob_properties=azure.storage.AccountBlobPropertiesArgs(
        versioning_enabled=True,
        change_feed_enabled=True,
    ))
dst_container = azure.storage.Container("dstContainer",
    storage_account_name=dst_account.name,
    container_access_type="private")
example = azure.storage.ObjectReplication("example",
    source_storage_account_id=src_account.id,
    destination_storage_account_id=dst_account.id,
    rules=[azure.storage.ObjectReplicationRuleArgs(
        source_container_name=src_container.name,
        destination_container_name=dst_container.name,
    )])