alicloud.hbr.ReplicationVault

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var sourceRegion = config.Get("sourceRegion") ?? "cn-hangzhou";
    var source = new AliCloud.Provider("source", new()
    {
        Region = sourceRegion,
    });

    var defaultReplicationVaultRegions = AliCloud.Hbr.GetReplicationVaultRegions.Invoke();

    var replication = new AliCloud.Provider("replication", new()
    {
        Region = defaultReplicationVaultRegions.Apply(getReplicationVaultRegionsResult => getReplicationVaultRegionsResult.Regions[0]?.ReplicationRegionId),
    });

    var defaultVault = new AliCloud.Hbr.Vault("defaultVault", new()
    {
        VaultName = "terraform-example",
    }, new CustomResourceOptions
    {
        Provider = alicloud.Source,
    });

    var defaultReplicationVault = new AliCloud.Hbr.ReplicationVault("defaultReplicationVault", new()
    {
        ReplicationSourceRegionId = sourceRegion,
        ReplicationSourceVaultId = defaultVault.Id,
        VaultName = "terraform-example",
        VaultStorageClass = "STANDARD",
        Description = "terraform-example",
    }, new CustomResourceOptions
    {
        Provider = alicloud.Replication,
    });

});

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/hbr"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		sourceRegion := "cn-hangzhou"
		if param := cfg.Get("sourceRegion"); param != "" {
			sourceRegion = param
		}
		_, err := alicloud.NewProvider(ctx, "source", &alicloud.ProviderArgs{
			Region: pulumi.String(sourceRegion),
		})
		if err != nil {
			return err
		}
		defaultReplicationVaultRegions, err := hbr.GetReplicationVaultRegions(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = alicloud.NewProvider(ctx, "replication", &alicloud.ProviderArgs{
			Region: *pulumi.String(defaultReplicationVaultRegions.Regions[0].ReplicationRegionId),
		})
		if err != nil {
			return err
		}
		defaultVault, err := hbr.NewVault(ctx, "defaultVault", &hbr.VaultArgs{
			VaultName: pulumi.String("terraform-example"),
		}, pulumi.Provider(alicloud.Source))
		if err != nil {
			return err
		}
		_, err = hbr.NewReplicationVault(ctx, "defaultReplicationVault", &hbr.ReplicationVaultArgs{
			ReplicationSourceRegionId: pulumi.String(sourceRegion),
			ReplicationSourceVaultId:  defaultVault.ID(),
			VaultName:                 pulumi.String("terraform-example"),
			VaultStorageClass:         pulumi.String("STANDARD"),
			Description:               pulumi.String("terraform-example"),
		}, pulumi.Provider(alicloud.Replication))
		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.alicloud.Provider;
import com.pulumi.alicloud.ProviderArgs;
import com.pulumi.alicloud.hbr.HbrFunctions;
import com.pulumi.alicloud.hbr.inputs.GetReplicationVaultRegionsArgs;
import com.pulumi.alicloud.hbr.Vault;
import com.pulumi.alicloud.hbr.VaultArgs;
import com.pulumi.alicloud.hbr.ReplicationVault;
import com.pulumi.alicloud.hbr.ReplicationVaultArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        final var config = ctx.config();
        final var sourceRegion = config.get("sourceRegion").orElse("cn-hangzhou");
        var source = new Provider("source", ProviderArgs.builder()        
            .region(sourceRegion)
            .build());

        final var defaultReplicationVaultRegions = HbrFunctions.getReplicationVaultRegions();

        var replication = new Provider("replication", ProviderArgs.builder()        
            .region(defaultReplicationVaultRegions.applyValue(getReplicationVaultRegionsResult -> getReplicationVaultRegionsResult.regions()[0].replicationRegionId()))
            .build());

        var defaultVault = new Vault("defaultVault", VaultArgs.builder()        
            .vaultName("terraform-example")
            .build(), CustomResourceOptions.builder()
                .provider(alicloud.source())
                .build());

        var defaultReplicationVault = new ReplicationVault("defaultReplicationVault", ReplicationVaultArgs.builder()        
            .replicationSourceRegionId(sourceRegion)
            .replicationSourceVaultId(defaultVault.id())
            .vaultName("terraform-example")
            .vaultStorageClass("STANDARD")
            .description("terraform-example")
            .build(), CustomResourceOptions.builder()
                .provider(alicloud.replication())
                .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
source_region = config.get("sourceRegion")
if source_region is None:
    source_region = "cn-hangzhou"
source = alicloud.Provider("source", region=source_region)
default_replication_vault_regions = alicloud.hbr.get_replication_vault_regions()
replication = alicloud.Provider("replication", region=default_replication_vault_regions.regions[0].replication_region_id)
default_vault = alicloud.hbr.Vault("defaultVault", vault_name="terraform-example",
opts=pulumi.ResourceOptions(provider=alicloud["source"]))
default_replication_vault = alicloud.hbr.ReplicationVault("defaultReplicationVault",
    replication_source_region_id=source_region,
    replication_source_vault_id=default_vault.id,
    vault_name="terraform-example",
    vault_storage_class="STANDARD",
    description="terraform-example",
    opts=pulumi.ResourceOptions(provider=alicloud["replication"]))

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

const config = new pulumi.Config();
const sourceRegion = config.get("sourceRegion") || "cn-hangzhou";
const source = new alicloud.Provider("source", {region: sourceRegion});
const defaultReplicationVaultRegions = alicloud.hbr.getReplicationVaultRegions({});
const replication = new alicloud.Provider("replication", {region: defaultReplicationVaultRegions.then(defaultReplicationVaultRegions => defaultReplicationVaultRegions.regions?.[0]?.replicationRegionId)});
const defaultVault = new alicloud.hbr.Vault("defaultVault", {vaultName: "terraform-example"}, {
    provider: alicloud.source,
});
const defaultReplicationVault = new alicloud.hbr.ReplicationVault("defaultReplicationVault", {
    replicationSourceRegionId: sourceRegion,
    replicationSourceVaultId: defaultVault.id,
    vaultName: "terraform-example",
    vaultStorageClass: "STANDARD",
    description: "terraform-example",
}, {
    provider: alicloud.replication,
});

configuration:
  sourceRegion:
    type: string
    default: cn-hangzhou
resources:
  source:
    type: pulumi:providers:alicloud
    properties:
      region: ${sourceRegion}
  replication:
    type: pulumi:providers:alicloud
    properties:
      region: ${defaultReplicationVaultRegions.regions[0].replicationRegionId}
  defaultVault:
    type: alicloud:hbr:Vault
    properties:
      vaultName: terraform-example
    options:
      provider: ${alicloud.source}
  defaultReplicationVault:
    type: alicloud:hbr:ReplicationVault
    properties:
      replicationSourceRegionId: ${sourceRegion}
      replicationSourceVaultId: ${defaultVault.id}
      vaultName: terraform-example
      vaultStorageClass: STANDARD
      description: terraform-example
    options:
      provider: ${alicloud.replication}
variables:
  defaultReplicationVaultRegions:
    fn::invoke:
      Function: alicloud:hbr:getReplicationVaultRegions
      Arguments: {}