rediscloud.SubscriptionPeering

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

return await Deployment.RunAsync(() => 
{
    var exampleSubscription = new Rediscloud.Subscription("exampleSubscription");

    // ...
    var exampleSubscriptionPeering = new Rediscloud.SubscriptionPeering("exampleSubscriptionPeering", new()
    {
        SubscriptionId = exampleSubscription.Id,
        Region = "eu-west-1",
        AwsAccountId = "123456789012",
        VpcId = "vpc-01234567890",
        VpcCidr = "10.0.0.0/8",
    });

    var example_peering = new Aws.Ec2.VpcPeeringConnectionAccepter("example-peering", new()
    {
        VpcPeeringConnectionId = exampleSubscriptionPeering.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 {
		exampleSubscription, err := rediscloud.NewSubscription(ctx, "exampleSubscription", nil)
		if err != nil {
			return err
		}
		exampleSubscriptionPeering, err := rediscloud.NewSubscriptionPeering(ctx, "exampleSubscriptionPeering", &rediscloud.SubscriptionPeeringArgs{
			SubscriptionId: exampleSubscription.ID(),
			Region:         pulumi.String("eu-west-1"),
			AwsAccountId:   pulumi.String("123456789012"),
			VpcId:          pulumi.String("vpc-01234567890"),
			VpcCidr:        pulumi.String("10.0.0.0/8"),
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewVpcPeeringConnectionAccepter(ctx, "example-peering", &ec2.VpcPeeringConnectionAccepterArgs{
			VpcPeeringConnectionId: exampleSubscriptionPeering.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.Subscription;
import com.pulumi.rediscloud.SubscriptionPeering;
import com.pulumi.rediscloud.SubscriptionPeeringArgs;
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 exampleSubscription = new Subscription("exampleSubscription");

        var exampleSubscriptionPeering = new SubscriptionPeering("exampleSubscriptionPeering", SubscriptionPeeringArgs.builder()        
            .subscriptionId(exampleSubscription.id())
            .region("eu-west-1")
            .awsAccountId("123456789012")
            .vpcId("vpc-01234567890")
            .vpcCidr("10.0.0.0/8")
            .build());

        var example_peering = new VpcPeeringConnectionAccepter("example-peering", VpcPeeringConnectionAccepterArgs.builder()        
            .vpcPeeringConnectionId(exampleSubscriptionPeering.awsPeeringId())
            .autoAccept(true)
            .build());

    }
}

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

const exampleSubscription = new rediscloud.Subscription("exampleSubscription", {});
// ...
const exampleSubscriptionPeering = new rediscloud.SubscriptionPeering("exampleSubscriptionPeering", {
    subscriptionId: exampleSubscription.id,
    region: "eu-west-1",
    awsAccountId: "123456789012",
    vpcId: "vpc-01234567890",
    vpcCidr: "10.0.0.0/8",
});
const example_peering = new aws.ec2.VpcPeeringConnectionAccepter("example-peering", {
    vpcPeeringConnectionId: exampleSubscriptionPeering.awsPeeringId,
    autoAccept: true,
});

import pulumi
import pulumi_aws as aws
import pulumi_rediscloud as rediscloud

example_subscription = rediscloud.Subscription("exampleSubscription")
# ...
example_subscription_peering = rediscloud.SubscriptionPeering("exampleSubscriptionPeering",
    subscription_id=example_subscription.id,
    region="eu-west-1",
    aws_account_id="123456789012",
    vpc_id="vpc-01234567890",
    vpc_cidr="10.0.0.0/8")
example_peering = aws.ec2.VpcPeeringConnectionAccepter("example-peering",
    vpc_peering_connection_id=example_subscription_peering.aws_peering_id,
    auto_accept=True)

resources:
  exampleSubscription:
    type: rediscloud:Subscription
  exampleSubscriptionPeering:
    type: rediscloud:SubscriptionPeering
    properties:
      subscriptionId: ${exampleSubscription.id}
      region: eu-west-1
      awsAccountId: '123456789012'
      vpcId: vpc-01234567890
      vpcCidr: 10.0.0.0/8
  example-peering:
    type: aws:ec2:VpcPeeringConnectionAccepter
    properties:
      vpcPeeringConnectionId: ${exampleSubscriptionPeering.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 example = new Rediscloud.Subscription("example");

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

    var example_peeringSubscriptionPeering = new Rediscloud.SubscriptionPeering("example-peeringSubscriptionPeering", new()
    {
        SubscriptionId = example.Id,
        ProviderName = "GCP",
        GcpProjectId = network.Apply(getNetworkResult => getNetworkResult.Project),
        GcpNetworkName = network.Apply(getNetworkResult => getNetworkResult.Name),
    });

    var example_peeringNetworkPeering = new Gcp.Compute.NetworkPeering("example-peeringNetworkPeering", new()
    {
        Network = network.Apply(getNetworkResult => getNetworkResult.SelfLink),
        PeerNetwork = $"https://www.googleapis.com/compute/v1/projects/{rediscloud_subscription_peering.Example.Gcp_redis_project_id}/global/networks/{rediscloud_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 {
		example, err := rediscloud.NewSubscription(ctx, "example", 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.NewSubscriptionPeering(ctx, "example-peeringSubscriptionPeering", &rediscloud.SubscriptionPeeringArgs{
			SubscriptionId: example.ID(),
			ProviderName:   pulumi.String("GCP"),
			GcpProjectId:   *pulumi.String(network.Project),
			GcpNetworkName: *pulumi.String(network.Name),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetworkPeering(ctx, "example-peeringNetworkPeering", &compute.NetworkPeeringArgs{
			Network:     *pulumi.String(network.SelfLink),
			PeerNetwork: pulumi.String(fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%v/global/networks/%v", rediscloud_subscription_peering.Example.Gcp_redis_project_id, rediscloud_subscription_peering.Example.Gcp_redis_network_name)),
		})
		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.Subscription;
import com.pulumi.gcp.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
import com.pulumi.rediscloud.SubscriptionPeering;
import com.pulumi.rediscloud.SubscriptionPeeringArgs;
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 example = new Subscription("example");

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

        var example_peeringSubscriptionPeering = new SubscriptionPeering("example-peeringSubscriptionPeering", SubscriptionPeeringArgs.builder()        
            .subscriptionId(example.id())
            .providerName("GCP")
            .gcpProjectId(network.applyValue(getNetworkResult -> getNetworkResult.project()))
            .gcpNetworkName(network.applyValue(getNetworkResult -> getNetworkResult.name()))
            .build());

        var example_peeringNetworkPeering = new NetworkPeering("example-peeringNetworkPeering", NetworkPeeringArgs.builder()        
            .network(network.applyValue(getNetworkResult -> getNetworkResult.selfLink()))
            .peerNetwork(String.format("https://www.googleapis.com/compute/v1/projects/%s/global/networks/%s", rediscloud_subscription_peering.example().gcp_redis_project_id(),rediscloud_subscription_peering.example().gcp_redis_network_name()))
            .build());

    }
}

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

const example = new rediscloud.Subscription("example", {});
// ...
const network = gcp.compute.getNetwork({
    project: "my-gcp-project",
    name: "my-gcp-vpc",
});
const example_peeringSubscriptionPeering = new rediscloud.SubscriptionPeering("example-peeringSubscriptionPeering", {
    subscriptionId: example.id,
    providerName: "GCP",
    gcpProjectId: network.then(network => network.project),
    gcpNetworkName: network.then(network => network.name),
});
const example_peeringNetworkPeering = new gcp.compute.NetworkPeering("example-peeringNetworkPeering", {
    network: network.then(network => network.selfLink),
    peerNetwork: `https://www.googleapis.com/compute/v1/projects/${rediscloud_subscription_peering.example.gcp_redis_project_id}/global/networks/${rediscloud_subscription_peering.example.gcp_redis_network_name}`,
});

import pulumi
import pulumi_gcp as gcp
import pulumi_rediscloud as rediscloud

example = rediscloud.Subscription("example")
# ...
network = gcp.compute.get_network(project="my-gcp-project",
    name="my-gcp-vpc")
example_peering_subscription_peering = rediscloud.SubscriptionPeering("example-peeringSubscriptionPeering",
    subscription_id=example.id,
    provider_name="GCP",
    gcp_project_id=network.project,
    gcp_network_name=network.name)
example_peering_network_peering = gcp.compute.NetworkPeering("example-peeringNetworkPeering",
    network=network.self_link,
    peer_network=f"https://www.googleapis.com/compute/v1/projects/{rediscloud_subscription_peering['example']['gcp_redis_project_id']}/global/networks/{rediscloud_subscription_peering['example']['gcp_redis_network_name']}")

resources:
  example:
    type: rediscloud:Subscription
  example-peeringSubscriptionPeering:
    type: rediscloud:SubscriptionPeering
    properties:
      subscriptionId: ${example.id}
      providerName: GCP
      gcpProjectId: ${network.project}
      gcpNetworkName: ${network.name}
  example-peeringNetworkPeering:
    type: gcp:compute:NetworkPeering
    properties:
      network: ${network.selfLink}
      peerNetwork: https://www.googleapis.com/compute/v1/projects/${rediscloud_subscription_peering.example.gcp_redis_project_id}/global/networks/${rediscloud_subscription_peering.example.gcp_redis_network_name}
variables:
  network:
    fn::invoke:
      Function: gcp:compute:getNetwork
      Arguments:
        project: my-gcp-project
        name: my-gcp-vpc