timescale.PeeringConnection

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as time from "@pulumi/time";
import * as timescale from "@pulumi/timescale";

const config = new pulumi.Config();
const tsProjectId = config.require("tsProjectId");
const tsAccessKey = config.require("tsAccessKey");
const tsSecretKey = config.require("tsSecretKey");
// Create a Timescale VPC
const ts_test = new timescale.Vpcs("ts-test", {
    cidr: "10.0.0.0/24",
    name: "tf-test",
    regionCode: "us-east-1",
});
// ========================================
// VPC Peering Example (Cross-Region)
// ========================================
// Creating a test VPC in eu-central-1
const main = new aws.index.Vpc("main", {
    cidrBlock: "11.0.0.0/24",
    tags: {
        name: "tf-test-vpc-peering",
    },
});
// Requester's side of the VPC peering connection (Timescale).
const vpcPeer = new timescale.PeeringConnection("vpc_peer", {
    peerAccountId: "000000000000",
    peerRegionCode: "eu-central-1",
    peerVpcId: main.id,
    peerCidrBlocks: [
        "12.0.0.0/24",
        "12.1.0.0/24",
    ],
    timescaleVpcId: ts_test.vpcsId,
});
// Acceptor's side of the VPC peering connection (AWS).
const vpcPeerVpcPeeringConnectionAccepter = new aws.index.VpcPeeringConnectionAccepter("vpc_peer", {
    vpcPeeringConnectionId: vpcPeer.accepterProvisionedId,
    autoAccept: true,
});
// ========================================
// Transit Gateway Peering Example
// ========================================
// Wait for VPC peering to be fully established before creating TGW peering
const waitForVpcPeering = new time.index.Sleep("wait_for_vpc_peering", {createDuration: "120s"}, {
    dependsOn: [vpcPeerVpcPeeringConnectionAccepter],
});
// Create a test Transit Gateway in eu-central-1
const tgw = new aws.index.Ec2TransitGateway("tgw", {
    description: "TGW for Timescale peering",
    tags: {
        name: "tf-test-tgw",
    },
});
// Create Transit Gateway peering with Timescale
const tgwPeer = new timescale.PeeringConnection("tgw_peer", {
    peerAccountId: "000000000000",
    peerRegionCode: "eu-central-1",
    peerTgwId: tgw.id,
    peerCidrBlocks: [
        "16.0.0.0/24",
        "16.1.0.0/24",
    ],
    timescaleVpcId: ts_test.vpcsId,
}, {
    dependsOn: [waitForVpcPeering],
});
// Wait for TGW peering attachment to propagate to AWS
const waitForTgwAttachment = new time.index.Sleep("wait_for_tgw_attachment", {createDuration: "120s"}, {
    dependsOn: [tgwPeer],
});
// Accept the Transit Gateway attachment
const tgwPeerEc2TransitGatewayPeeringAttachmentAccepter = new aws.index.Ec2TransitGatewayPeeringAttachmentAccepter("tgw_peer", {transitGatewayAttachmentId: tgwPeer.accepterProvisionedId}, {
    dependsOn: [waitForTgwAttachment],
});

import pulumi
import pulumi_aws as aws
import pulumi_time as time
import pulumi_timescale as timescale

config = pulumi.Config()
ts_project_id = config.require("tsProjectId")
ts_access_key = config.require("tsAccessKey")
ts_secret_key = config.require("tsSecretKey")
# Create a Timescale VPC
ts_test = timescale.Vpcs("ts-test",
    cidr="10.0.0.0/24",
    name="tf-test",
    region_code="us-east-1")
# ========================================
# VPC Peering Example (Cross-Region)
# ========================================
# Creating a test VPC in eu-central-1
main = aws.index.Vpc("main",
    cidr_block=11.0.0.0/24,
    tags={
        name: tf-test-vpc-peering,
    })
# Requester's side of the VPC peering connection (Timescale).
vpc_peer = timescale.PeeringConnection("vpc_peer",
    peer_account_id="000000000000",
    peer_region_code="eu-central-1",
    peer_vpc_id=main["id"],
    peer_cidr_blocks=[
        "12.0.0.0/24",
        "12.1.0.0/24",
    ],
    timescale_vpc_id=ts_test.vpcs_id)
# Acceptor's side of the VPC peering connection (AWS).
vpc_peer_vpc_peering_connection_accepter = aws.index.VpcPeeringConnectionAccepter("vpc_peer",
    vpc_peering_connection_id=vpc_peer.accepter_provisioned_id,
    auto_accept=True)
# ========================================
# Transit Gateway Peering Example
# ========================================
# Wait for VPC peering to be fully established before creating TGW peering
wait_for_vpc_peering = time.index.Sleep("wait_for_vpc_peering", create_duration=120s,
opts = pulumi.ResourceOptions(depends_on=[vpc_peer_vpc_peering_connection_accepter]))
# Create a test Transit Gateway in eu-central-1
tgw = aws.index.Ec2TransitGateway("tgw",
    description=TGW for Timescale peering,
    tags={
        name: tf-test-tgw,
    })
# Create Transit Gateway peering with Timescale
tgw_peer = timescale.PeeringConnection("tgw_peer",
    peer_account_id="000000000000",
    peer_region_code="eu-central-1",
    peer_tgw_id=tgw["id"],
    peer_cidr_blocks=[
        "16.0.0.0/24",
        "16.1.0.0/24",
    ],
    timescale_vpc_id=ts_test.vpcs_id,
    opts = pulumi.ResourceOptions(depends_on=[wait_for_vpc_peering]))
# Wait for TGW peering attachment to propagate to AWS
wait_for_tgw_attachment = time.index.Sleep("wait_for_tgw_attachment", create_duration=120s,
opts = pulumi.ResourceOptions(depends_on=[tgw_peer]))
# Accept the Transit Gateway attachment
tgw_peer_ec2_transit_gateway_peering_attachment_accepter = aws.index.Ec2TransitGatewayPeeringAttachmentAccepter("tgw_peer", transit_gateway_attachment_id=tgw_peer.accepter_provisioned_id,
opts = pulumi.ResourceOptions(depends_on=[wait_for_tgw_attachment]))

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/timescale/v2/timescale"
	"github.com/pulumi/pulumi-time/sdk/go/time"
	"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, "")
		tsProjectId := cfg.Require("tsProjectId")
		tsAccessKey := cfg.Require("tsAccessKey")
		tsSecretKey := cfg.Require("tsSecretKey")
		// Create a Timescale VPC
		ts_test, err := timescale.NewVpcs(ctx, "ts-test", &timescale.VpcsArgs{
			Cidr:       pulumi.String("10.0.0.0/24"),
			Name:       pulumi.String("tf-test"),
			RegionCode: pulumi.String("us-east-1"),
		})
		if err != nil {
			return err
		}
		// Creating a test VPC in eu-central-1
		main, err := aws.NewVpc(ctx, "main", &aws.VpcArgs{
			CidrBlock: "11.0.0.0/24",
			Tags: map[string]interface{}{
				"name": "tf-test-vpc-peering",
			},
		})
		if err != nil {
			return err
		}
		// Requester's side of the VPC peering connection (Timescale).
		vpcPeer, err := timescale.NewPeeringConnection(ctx, "vpc_peer", &timescale.PeeringConnectionArgs{
			PeerAccountId:  pulumi.String("000000000000"),
			PeerRegionCode: pulumi.String("eu-central-1"),
			PeerVpcId:      main.Id,
			PeerCidrBlocks: pulumi.StringArray{
				pulumi.String("12.0.0.0/24"),
				pulumi.String("12.1.0.0/24"),
			},
			TimescaleVpcId: ts_test.VpcsId,
		})
		if err != nil {
			return err
		}
		// Acceptor's side of the VPC peering connection (AWS).
		vpcPeerVpcPeeringConnectionAccepter, err := aws.NewVpcPeeringConnectionAccepter(ctx, "vpc_peer", &aws.VpcPeeringConnectionAccepterArgs{
			VpcPeeringConnectionId: vpcPeer.AccepterProvisionedId,
			AutoAccept:             true,
		})
		if err != nil {
			return err
		}
		// Wait for VPC peering to be fully established before creating TGW peering
		waitForVpcPeering, err := time.NewSleep(ctx, "wait_for_vpc_peering", &time.SleepArgs{
			CreateDuration: "120s",
		}, pulumi.DependsOn([]pulumi.Resource{
			vpcPeerVpcPeeringConnectionAccepter,
		}))
		if err != nil {
			return err
		}
		// Create a test Transit Gateway in eu-central-1
		tgw, err := aws.NewEc2TransitGateway(ctx, "tgw", &aws.Ec2TransitGatewayArgs{
			Description: "TGW for Timescale peering",
			Tags: map[string]interface{}{
				"name": "tf-test-tgw",
			},
		})
		if err != nil {
			return err
		}
		// Create Transit Gateway peering with Timescale
		tgwPeer, err := timescale.NewPeeringConnection(ctx, "tgw_peer", &timescale.PeeringConnectionArgs{
			PeerAccountId:  pulumi.String("000000000000"),
			PeerRegionCode: pulumi.String("eu-central-1"),
			PeerTgwId:      tgw.Id,
			PeerCidrBlocks: pulumi.StringArray{
				pulumi.String("16.0.0.0/24"),
				pulumi.String("16.1.0.0/24"),
			},
			TimescaleVpcId: ts_test.VpcsId,
		}, pulumi.DependsOn([]pulumi.Resource{
			waitForVpcPeering,
		}))
		if err != nil {
			return err
		}
		// Wait for TGW peering attachment to propagate to AWS
		waitForTgwAttachment, err := time.NewSleep(ctx, "wait_for_tgw_attachment", &time.SleepArgs{
			CreateDuration: "120s",
		}, pulumi.DependsOn([]pulumi.Resource{
			tgwPeer,
		}))
		if err != nil {
			return err
		}
		// Accept the Transit Gateway attachment
		_, err = aws.NewEc2TransitGatewayPeeringAttachmentAccepter(ctx, "tgw_peer", &aws.Ec2TransitGatewayPeeringAttachmentAccepterArgs{
			TransitGatewayAttachmentId: tgwPeer.AccepterProvisionedId,
		}, pulumi.DependsOn([]pulumi.Resource{
			waitForTgwAttachment,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Time = Pulumi.Time;
using Timescale = Pulumi.Timescale;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var tsProjectId = config.Require("tsProjectId");
    var tsAccessKey = config.Require("tsAccessKey");
    var tsSecretKey = config.Require("tsSecretKey");
    // Create a Timescale VPC
    var ts_test = new Timescale.Vpcs("ts-test", new()
    {
        Cidr = "10.0.0.0/24",
        Name = "tf-test",
        RegionCode = "us-east-1",
    });

    // ========================================
    // VPC Peering Example (Cross-Region)
    // ========================================
    // Creating a test VPC in eu-central-1
    var main = new Aws.Index.Vpc("main", new()
    {
        CidrBlock = "11.0.0.0/24",
        Tags = 
        {
            { "name", "tf-test-vpc-peering" },
        },
    });

    // Requester's side of the VPC peering connection (Timescale).
    var vpcPeer = new Timescale.PeeringConnection("vpc_peer", new()
    {
        PeerAccountId = "000000000000",
        PeerRegionCode = "eu-central-1",
        PeerVpcId = main.Id,
        PeerCidrBlocks = new[]
        {
            "12.0.0.0/24",
            "12.1.0.0/24",
        },
        TimescaleVpcId = ts_test.VpcsId,
    });

    // Acceptor's side of the VPC peering connection (AWS).
    var vpcPeerVpcPeeringConnectionAccepter = new Aws.Index.VpcPeeringConnectionAccepter("vpc_peer", new()
    {
        VpcPeeringConnectionId = vpcPeer.AccepterProvisionedId,
        AutoAccept = true,
    });

    // ========================================
    // Transit Gateway Peering Example
    // ========================================
    // Wait for VPC peering to be fully established before creating TGW peering
    var waitForVpcPeering = new Time.Index.Sleep("wait_for_vpc_peering", new()
    {
        CreateDuration = "120s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpcPeerVpcPeeringConnectionAccepter,
        },
    });

    // Create a test Transit Gateway in eu-central-1
    var tgw = new Aws.Index.Ec2TransitGateway("tgw", new()
    {
        Description = "TGW for Timescale peering",
        Tags = 
        {
            { "name", "tf-test-tgw" },
        },
    });

    // Create Transit Gateway peering with Timescale
    var tgwPeer = new Timescale.PeeringConnection("tgw_peer", new()
    {
        PeerAccountId = "000000000000",
        PeerRegionCode = "eu-central-1",
        PeerTgwId = tgw.Id,
        PeerCidrBlocks = new[]
        {
            "16.0.0.0/24",
            "16.1.0.0/24",
        },
        TimescaleVpcId = ts_test.VpcsId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            waitForVpcPeering,
        },
    });

    // Wait for TGW peering attachment to propagate to AWS
    var waitForTgwAttachment = new Time.Index.Sleep("wait_for_tgw_attachment", new()
    {
        CreateDuration = "120s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            tgwPeer,
        },
    });

    // Accept the Transit Gateway attachment
    var tgwPeerEc2TransitGatewayPeeringAttachmentAccepter = new Aws.Index.Ec2TransitGatewayPeeringAttachmentAccepter("tgw_peer", new()
    {
        TransitGatewayAttachmentId = tgwPeer.AccepterProvisionedId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            waitForTgwAttachment,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.timescale.Vpcs;
import com.pulumi.timescale.VpcsArgs;
import com.pulumi.aws.Vpc;
import com.pulumi.aws.VpcArgs;
import com.pulumi.timescale.PeeringConnection;
import com.pulumi.timescale.PeeringConnectionArgs;
import com.pulumi.aws.VpcPeeringConnectionAccepter;
import com.pulumi.aws.VpcPeeringConnectionAccepterArgs;
import com.pulumi.time.Sleep;
import com.pulumi.time.SleepArgs;
import com.pulumi.aws.Ec2TransitGateway;
import com.pulumi.aws.Ec2TransitGatewayArgs;
import com.pulumi.aws.Ec2TransitGatewayPeeringAttachmentAccepter;
import com.pulumi.aws.Ec2TransitGatewayPeeringAttachmentAccepterArgs;
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 tsProjectId = config.get("tsProjectId");
        final var tsAccessKey = config.get("tsAccessKey");
        final var tsSecretKey = config.get("tsSecretKey");
        // Create a Timescale VPC
        var ts_test = new Vpcs("ts-test", VpcsArgs.builder()
            .cidr("10.0.0.0/24")
            .name("tf-test")
            .regionCode("us-east-1")
            .build());

        // ========================================
        // VPC Peering Example (Cross-Region)
        // ========================================
        // Creating a test VPC in eu-central-1
        var main = new Vpc("main", VpcArgs.builder()
            .cidrBlock("11.0.0.0/24")
            .tags(Map.of("name", "tf-test-vpc-peering"))
            .build());

        // Requester's side of the VPC peering connection (Timescale).
        var vpcPeer = new PeeringConnection("vpcPeer", PeeringConnectionArgs.builder()
            .peerAccountId("000000000000")
            .peerRegionCode("eu-central-1")
            .peerVpcId(main.id())
            .peerCidrBlocks(            
                "12.0.0.0/24",
                "12.1.0.0/24")
            .timescaleVpcId(ts_test.vpcsId())
            .build());

        // Acceptor's side of the VPC peering connection (AWS).
        var vpcPeerVpcPeeringConnectionAccepter = new VpcPeeringConnectionAccepter("vpcPeerVpcPeeringConnectionAccepter", VpcPeeringConnectionAccepterArgs.builder()
            .vpcPeeringConnectionId(vpcPeer.accepterProvisionedId())
            .autoAccept(true)
            .build());

        // ========================================
        // Transit Gateway Peering Example
        // ========================================
        // Wait for VPC peering to be fully established before creating TGW peering
        var waitForVpcPeering = new Sleep("waitForVpcPeering", SleepArgs.builder()
            .createDuration("120s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(vpcPeerVpcPeeringConnectionAccepter))
                .build());

        // Create a test Transit Gateway in eu-central-1
        var tgw = new Ec2TransitGateway("tgw", Ec2TransitGatewayArgs.builder()
            .description("TGW for Timescale peering")
            .tags(Map.of("name", "tf-test-tgw"))
            .build());

        // Create Transit Gateway peering with Timescale
        var tgwPeer = new PeeringConnection("tgwPeer", PeeringConnectionArgs.builder()
            .peerAccountId("000000000000")
            .peerRegionCode("eu-central-1")
            .peerTgwId(tgw.id())
            .peerCidrBlocks(            
                "16.0.0.0/24",
                "16.1.0.0/24")
            .timescaleVpcId(ts_test.vpcsId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(waitForVpcPeering)
                .build());

        // Wait for TGW peering attachment to propagate to AWS
        var waitForTgwAttachment = new Sleep("waitForTgwAttachment", SleepArgs.builder()
            .createDuration("120s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(tgwPeer))
                .build());

        // Accept the Transit Gateway attachment
        var tgwPeerEc2TransitGatewayPeeringAttachmentAccepter = new Ec2TransitGatewayPeeringAttachmentAccepter("tgwPeerEc2TransitGatewayPeeringAttachmentAccepter", Ec2TransitGatewayPeeringAttachmentAccepterArgs.builder()
            .transitGatewayAttachmentId(tgwPeer.accepterProvisionedId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(waitForTgwAttachment))
                .build());

    }
}

configuration:
  tsProjectId:
    type: string
  tsAccessKey:
    type: string
  tsSecretKey:
    type: string
resources:
  # Create a Timescale VPC
  ts-test: # ========================================
  # VPC Peering Example (Cross-Region)
  # ========================================
    type: timescale:Vpcs
    properties:
      cidr: 10.0.0.0/24
      name: tf-test
      regionCode: us-east-1
  # Creating a test VPC in eu-central-1
  main:
    type: aws:Vpc
    properties:
      cidrBlock: 11.0.0.0/24
      tags:
        name: tf-test-vpc-peering
  # Requester's side of the VPC peering connection (Timescale).
  vpcPeer:
    type: timescale:PeeringConnection
    name: vpc_peer
    properties:
      peerAccountId: '000000000000'
      peerRegionCode: eu-central-1
      peerVpcId: ${main.id}
      peerCidrBlocks: # Optional for VPC peering
        - 12.0.0.0/24
        - 12.1.0.0/24
      timescaleVpcId: ${["ts-test"].vpcsId}
  # Acceptor's side of the VPC peering connection (AWS).
  vpcPeerVpcPeeringConnectionAccepter: # ========================================
  # Transit Gateway Peering Example
  # ========================================
    type: aws:VpcPeeringConnectionAccepter
    name: vpc_peer
    properties:
      vpcPeeringConnectionId: ${vpcPeer.accepterProvisionedId}
      autoAccept: true
  # Wait for VPC peering to be fully established before creating TGW peering
  waitForVpcPeering:
    type: time:Sleep
    name: wait_for_vpc_peering
    properties:
      createDuration: 120s
    options:
      dependsOn:
        - ${vpcPeerVpcPeeringConnectionAccepter}
  # Create a test Transit Gateway in eu-central-1
  tgw:
    type: aws:Ec2TransitGateway
    properties:
      description: TGW for Timescale peering
      tags:
        name: tf-test-tgw
  # Create Transit Gateway peering with Timescale
  tgwPeer:
    type: timescale:PeeringConnection
    name: tgw_peer
    properties:
      peerAccountId: '000000000000'
      peerRegionCode: eu-central-1
      peerTgwId: ${tgw.id}
      peerCidrBlocks: # Required for TGW peering.
        - 16.0.0.0/24
        - 16.1.0.0/24
      timescaleVpcId: ${["ts-test"].vpcsId}
    options:
      dependsOn:
        - ${waitForVpcPeering}
  # Wait for TGW peering attachment to propagate to AWS
  waitForTgwAttachment:
    type: time:Sleep
    name: wait_for_tgw_attachment
    properties:
      createDuration: 120s
    options:
      dependsOn:
        - ${tgwPeer}
  # Accept the Transit Gateway attachment
  tgwPeerEc2TransitGatewayPeeringAttachmentAccepter:
    type: aws:Ec2TransitGatewayPeeringAttachmentAccepter
    name: tgw_peer
    properties:
      transitGatewayAttachmentId: ${tgwPeer.accepterProvisionedId}
    options:
      dependsOn:
        - ${waitForTgwAttachment}

var peeringConnectionResource = new Timescale.PeeringConnection("peeringConnectionResource", new()
{
    PeerAccountId = "string",
    PeerRegionCode = "string",
    TimescaleVpcId = 0,
    PeerCidrBlocks = new[]
    {
        "string",
    },
    PeerTgwId = "string",
    PeerVpcId = "string",
});

example, err := timescale.NewPeeringConnection(ctx, "peeringConnectionResource", &timescale.PeeringConnectionArgs{
	PeerAccountId:  pulumi.String("string"),
	PeerRegionCode: pulumi.String("string"),
	TimescaleVpcId: pulumi.Float64(0),
	PeerCidrBlocks: pulumi.StringArray{
		pulumi.String("string"),
	},
	PeerTgwId: pulumi.String("string"),
	PeerVpcId: pulumi.String("string"),
})

var peeringConnectionResource = new PeeringConnection("peeringConnectionResource", PeeringConnectionArgs.builder()
    .peerAccountId("string")
    .peerRegionCode("string")
    .timescaleVpcId(0.0)
    .peerCidrBlocks("string")
    .peerTgwId("string")
    .peerVpcId("string")
    .build());

peering_connection_resource = timescale.PeeringConnection("peeringConnectionResource",
    peer_account_id="string",
    peer_region_code="string",
    timescale_vpc_id=0,
    peer_cidr_blocks=["string"],
    peer_tgw_id="string",
    peer_vpc_id="string")

const peeringConnectionResource = new timescale.PeeringConnection("peeringConnectionResource", {
    peerAccountId: "string",
    peerRegionCode: "string",
    timescaleVpcId: 0,
    peerCidrBlocks: ["string"],
    peerTgwId: "string",
    peerVpcId: "string",
});

type: timescale:PeeringConnection
properties:
    peerAccountId: string
    peerCidrBlocks:
        - string
    peerRegionCode: string
    peerTgwId: string
    peerVpcId: string
    timescaleVpcId: 0