rediscloud.SubscriptionPeering

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 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