rediscloud.ActiveActiveSubscriptionPeering

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Rediscloud = RedisLabs.Rediscloud;

return await Deployment.RunAsync(() => 
{
    var subscription_resource = new Rediscloud.ActiveActiveSubscription("subscription-resource");

    // ...
    var peering_resource = new Rediscloud.ActiveActiveSubscriptionPeering("peering-resource", new()
    {
        SubscriptionId = subscription_resource.Id,
        SourceRegion = "us-east-1",
        DestinationRegion = "eu-west-2",
        AwsAccountId = "123456789012",
        VpcId = "vpc-01234567890",
        VpcCidr = "10.0.10.0/24",
    });

    var aws_peering_resource = new Aws.Ec2.VpcPeeringConnectionAccepter("aws-peering-resource", new()
    {
        VpcPeeringConnectionId = peering_resource.AwsPeeringId,
        AutoAccept = true,
    });

});

package main

import (
	"github.com/RedisLabs/pulumi-rediscloud/sdk/go/rediscloud"
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rediscloud.NewActiveActiveSubscription(ctx, "subscription-resource", nil)
		if err != nil {
			return err
		}
		_, err = rediscloud.NewActiveActiveSubscriptionPeering(ctx, "peering-resource", &rediscloud.ActiveActiveSubscriptionPeeringArgs{
			SubscriptionId:    subscription_resource.ID(),
			SourceRegion:      pulumi.String("us-east-1"),
			DestinationRegion: pulumi.String("eu-west-2"),
			AwsAccountId:      pulumi.String("123456789012"),
			VpcId:             pulumi.String("vpc-01234567890"),
			VpcCidr:           pulumi.String("10.0.10.0/24"),
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewVpcPeeringConnectionAccepter(ctx, "aws-peering-resource", &ec2.VpcPeeringConnectionAccepterArgs{
			VpcPeeringConnectionId: peering_resource.AwsPeeringId,
			AutoAccept:             pulumi.Bool(true),
		})
		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.rediscloud.ActiveActiveSubscription;
import com.pulumi.rediscloud.ActiveActiveSubscriptionPeering;
import com.pulumi.rediscloud.ActiveActiveSubscriptionPeeringArgs;
import com.pulumi.aws.ec2.VpcPeeringConnectionAccepter;
import com.pulumi.aws.ec2.VpcPeeringConnectionAccepterArgs;
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 subscription_resource = new ActiveActiveSubscription("subscription-resource");

        var peering_resource = new ActiveActiveSubscriptionPeering("peering-resource", ActiveActiveSubscriptionPeeringArgs.builder()        
            .subscriptionId(subscription_resource.id())
            .sourceRegion("us-east-1")
            .destinationRegion("eu-west-2")
            .awsAccountId("123456789012")
            .vpcId("vpc-01234567890")
            .vpcCidr("10.0.10.0/24")
            .build());

        var aws_peering_resource = new VpcPeeringConnectionAccepter("aws-peering-resource", VpcPeeringConnectionAccepterArgs.builder()        
            .vpcPeeringConnectionId(peering_resource.awsPeeringId())
            .autoAccept(true)
            .build());

    }
}

import pulumi
import pulumi_aws as aws
import pulumi_rediscloud as rediscloud

subscription_resource = rediscloud.ActiveActiveSubscription("subscription-resource")
# ...
peering_resource = rediscloud.ActiveActiveSubscriptionPeering("peering-resource",
    subscription_id=subscription_resource.id,
    source_region="us-east-1",
    destination_region="eu-west-2",
    aws_account_id="123456789012",
    vpc_id="vpc-01234567890",
    vpc_cidr="10.0.10.0/24")
aws_peering_resource = aws.ec2.VpcPeeringConnectionAccepter("aws-peering-resource",
    vpc_peering_connection_id=peering_resource.aws_peering_id,
    auto_accept=True)

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

const subscription_resource = new rediscloud.ActiveActiveSubscription("subscription-resource", {});
// ...
const peering_resource = new rediscloud.ActiveActiveSubscriptionPeering("peering-resource", {
    subscriptionId: subscription_resource.id,
    sourceRegion: "us-east-1",
    destinationRegion: "eu-west-2",
    awsAccountId: "123456789012",
    vpcId: "vpc-01234567890",
    vpcCidr: "10.0.10.0/24",
});
const aws_peering_resource = new aws.ec2.VpcPeeringConnectionAccepter("aws-peering-resource", {
    vpcPeeringConnectionId: peering_resource.awsPeeringId,
    autoAccept: true,
});

resources:
  subscription-resource:
    type: rediscloud:ActiveActiveSubscription
  peering-resource:
    type: rediscloud:ActiveActiveSubscriptionPeering
    properties:
      subscriptionId: ${["subscription-resource"].id}
      sourceRegion: us-east-1
      destinationRegion: eu-west-2
      awsAccountId: '123456789012'
      vpcId: vpc-01234567890
      vpcCidr: 10.0.10.0/24
  aws-peering-resource:
    type: aws:ec2:VpcPeeringConnectionAccepter
    properties:
      vpcPeeringConnectionId: ${["peering-resource"].awsPeeringId}
      autoAccept: true

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Rediscloud = RedisLabs.Rediscloud;

return await Deployment.RunAsync(() => 
{
    var subscription_resource = new Rediscloud.ActiveActiveSubscription("subscription-resource");

    // ...
    var network = Gcp.Compute.GetNetwork.Invoke(new()
    {
        Project = "my-gcp-project",
        Name = "my-gcp-vpc",
    });

    var peering_resource = new Rediscloud.ActiveActiveSubscriptionPeering("peering-resource", new()
    {
        SubscriptionId = subscription_resource.Id,
        SourceRegion = "us-central1",
        ProviderName = "GCP",
        GcpProjectId = network.Apply(getNetworkResult => getNetworkResult.Project),
        GcpNetworkName = network.Apply(getNetworkResult => getNetworkResult.Name),
    });

    var gcp_peering_resource = new Gcp.Compute.NetworkPeering("gcp-peering-resource", new()
    {
        Network = network.Apply(getNetworkResult => getNetworkResult.SelfLink),
        PeerNetwork = peering_resource.GcpRedisProjectId.Apply(gcpRedisProjectId => $"https://www.googleapis.com/compute/v1/projects/{gcpRedisProjectId}/global/networks/{rediscloud_active_active_subscription_peering.Example.Gcp_redis_network_name}"),
    });

});

package main

import (
	"fmt"

	"github.com/RedisLabs/pulumi-rediscloud/sdk/go/rediscloud"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rediscloud.NewActiveActiveSubscription(ctx, "subscription-resource", nil)
		if err != nil {
			return err
		}
		network, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
			Project: pulumi.StringRef("my-gcp-project"),
			Name:    "my-gcp-vpc",
		}, nil)
		if err != nil {
			return err
		}
		_, err = rediscloud.NewActiveActiveSubscriptionPeering(ctx, "peering-resource", &rediscloud.ActiveActiveSubscriptionPeeringArgs{
			SubscriptionId: subscription_resource.ID(),
			SourceRegion:   pulumi.String("us-central1"),
			ProviderName:   pulumi.String("GCP"),
			GcpProjectId:   *pulumi.String(network.Project),
			GcpNetworkName: *pulumi.String(network.Name),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetworkPeering(ctx, "gcp-peering-resource", &compute.NetworkPeeringArgs{
			Network: *pulumi.String(network.SelfLink),
			PeerNetwork: peering_resource.GcpRedisProjectId.ApplyT(func(gcpRedisProjectId string) (string, error) {
				return fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%v/global/networks/%v", gcpRedisProjectId, rediscloud_active_active_subscription_peering.Example.Gcp_redis_network_name), 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.rediscloud.ActiveActiveSubscription;
import com.pulumi.gcp.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
import com.pulumi.rediscloud.ActiveActiveSubscriptionPeering;
import com.pulumi.rediscloud.ActiveActiveSubscriptionPeeringArgs;
import com.pulumi.gcp.compute.NetworkPeering;
import com.pulumi.gcp.compute.NetworkPeeringArgs;
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 subscription_resource = new ActiveActiveSubscription("subscription-resource");

        final var network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .project("my-gcp-project")
            .name("my-gcp-vpc")
            .build());

        var peering_resource = new ActiveActiveSubscriptionPeering("peering-resource", ActiveActiveSubscriptionPeeringArgs.builder()        
            .subscriptionId(subscription_resource.id())
            .sourceRegion("us-central1")
            .providerName("GCP")
            .gcpProjectId(network.applyValue(getNetworkResult -> getNetworkResult.project()))
            .gcpNetworkName(network.applyValue(getNetworkResult -> getNetworkResult.name()))
            .build());

        var gcp_peering_resource = new NetworkPeering("gcp-peering-resource", NetworkPeeringArgs.builder()        
            .network(network.applyValue(getNetworkResult -> getNetworkResult.selfLink()))
            .peerNetwork(peering_resource.gcpRedisProjectId().applyValue(gcpRedisProjectId -> String.format("https://www.googleapis.com/compute/v1/projects/%s/global/networks/%s", gcpRedisProjectId,rediscloud_active_active_subscription_peering.example().gcp_redis_network_name())))
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp
import pulumi_rediscloud as rediscloud

subscription_resource = rediscloud.ActiveActiveSubscription("subscription-resource")
# ...
network = gcp.compute.get_network(project="my-gcp-project",
    name="my-gcp-vpc")
peering_resource = rediscloud.ActiveActiveSubscriptionPeering("peering-resource",
    subscription_id=subscription_resource.id,
    source_region="us-central1",
    provider_name="GCP",
    gcp_project_id=network.project,
    gcp_network_name=network.name)
gcp_peering_resource = gcp.compute.NetworkPeering("gcp-peering-resource",
    network=network.self_link,
    peer_network=peering_resource.gcp_redis_project_id.apply(lambda gcp_redis_project_id: f"https://www.googleapis.com/compute/v1/projects/{gcp_redis_project_id}/global/networks/{rediscloud_active_active_subscription_peering['example']['gcp_redis_network_name']}"))

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as rediscloud from "@rediscloud/pulumi-rediscloud";

const subscription_resource = new rediscloud.ActiveActiveSubscription("subscription-resource", {});
// ...
const network = gcp.compute.getNetwork({
    project: "my-gcp-project",
    name: "my-gcp-vpc",
});
const peering_resource = new rediscloud.ActiveActiveSubscriptionPeering("peering-resource", {
    subscriptionId: subscription_resource.id,
    sourceRegion: "us-central1",
    providerName: "GCP",
    gcpProjectId: network.then(network => network.project),
    gcpNetworkName: network.then(network => network.name),
});
const gcp_peering_resource = new gcp.compute.NetworkPeering("gcp-peering-resource", {
    network: network.then(network => network.selfLink),
    peerNetwork: pulumi.interpolate`https://www.googleapis.com/compute/v1/projects/${peering_resource.gcpRedisProjectId}/global/networks/${rediscloud_active_active_subscription_peering.example.gcp_redis_network_name}`,
});

resources:
  subscription-resource:
    type: rediscloud:ActiveActiveSubscription
  peering-resource:
    type: rediscloud:ActiveActiveSubscriptionPeering
    properties:
      subscriptionId: ${["subscription-resource"].id}
      sourceRegion: us-central1
      providerName: GCP
      gcpProjectId: ${network.project}
      gcpNetworkName: ${network.name}
  gcp-peering-resource:
    type: gcp:compute:NetworkPeering
    properties:
      network: ${network.selfLink}
      peerNetwork: https://www.googleapis.com/compute/v1/projects/${["peering-resource"].gcpRedisProjectId}/global/networks/${rediscloud_active_active_subscription_peering.example.gcp_redis_network_name}
variables:
  network:
    fn::invoke:
      Function: gcp:compute:getNetwork
      Arguments:
        project: my-gcp-project
        name: my-gcp-vpc