VpcPeering

CloudAMQP v3.27.1, Mar 20 26

Viewing docs for CloudAMQP v3.27.1
published on Friday, Mar 20, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-cloudamqp

Viewing docs for CloudAMQP v3.27.1
published on Friday, Mar 20, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-cloudamqp

Example Usage

One way to manage the vpc peering is to combine CloudAMQP Terraform provider with AWS Terraform provider and run them at the same time.

AWS VPC peering before v1.16.0

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as cloudamqp from "@pulumi/cloudamqp";

// CloudAMQP - new instance, need to be created with a vpc
const instance = new cloudamqp.Instance("instance", {
    name: "terraform-vpc-accepter",
    plan: "penguin-1",
    region: "amazon-web-services::us-east-1",
    tags: ["terraform"],
    vpcSubnet: "10.40.72.0/24",
});
// CloudAMQP - Extract vpc information
const vpcInfo = instance.id.apply(id => cloudamqp.getVpcInfoOutput({
    instanceId: id,
}));
// AWS - retrieve instance to get subnet identifier
const awsInstance = aws.index.Instance({
    instanceTags: {
        name: awsInstanceName,
    },
});
// AWS - retrieve subnet
const subnet = aws.index.Subnet({
    id: awsInstance.subnetId,
});
// AWS - Create peering request
const awsVpcPeering = new aws.index.VpcPeeringConnection("aws_vpc_peering", {
    vpcId: subnet.vpcId,
    peerVpcId: vpcInfo.id,
    peerOwnerId: vpcInfo.ownerId,
    tags: {
        name: awsPeeringName,
    },
});
// CloudAMQP - accept the peering request
const vpcAcceptPeering = new cloudamqp.VpcPeering("vpc_accept_peering", {
    instanceId: instance.id,
    peeringId: awsVpcPeering.id,
});
// AWS - retrieve the route table created in AWS
const routeTable = aws.index.RouteTable({
    vpcId: subnet.vpcId,
});
// AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
const accepterRoute = new aws.index.Route("accepter_route", {
    routeTableId: routeTable.routeTableId,
    destinationCidrBlock: instance.vpcSubnet,
    vpcPeeringConnectionId: awsVpcPeering.id,
}, {
    dependsOn: [vpcAcceptPeering],
});

import pulumi
import pulumi_aws as aws
import pulumi_cloudamqp as cloudamqp

# CloudAMQP - new instance, need to be created with a vpc
instance = cloudamqp.Instance("instance",
    name="terraform-vpc-accepter",
    plan="penguin-1",
    region="amazon-web-services::us-east-1",
    tags=["terraform"],
    vpc_subnet="10.40.72.0/24")
# CloudAMQP - Extract vpc information
vpc_info = instance.id.apply(lambda id: cloudamqp.get_vpc_info_output(instance_id=id))
# AWS - retrieve instance to get subnet identifier
aws_instance = aws.index.instance(instance_tags={
    "name": aws_instance_name,
})
# AWS - retrieve subnet
subnet = aws.index.subnet(id=aws_instance["subnetId"])
# AWS - Create peering request
aws_vpc_peering = aws.index.VpcPeeringConnection("aws_vpc_peering",
    vpc_id=subnet.vpc_id,
    peer_vpc_id=vpc_info.id,
    peer_owner_id=vpc_info.owner_id,
    tags={
        name: aws_peering_name,
    })
# CloudAMQP - accept the peering request
vpc_accept_peering = cloudamqp.VpcPeering("vpc_accept_peering",
    instance_id=instance.id,
    peering_id=aws_vpc_peering["id"])
# AWS - retrieve the route table created in AWS
route_table = aws.index.route_table(vpc_id=subnet["vpcId"])
# AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
accepter_route = aws.index.Route("accepter_route",
    route_table_id=route_table.route_table_id,
    destination_cidr_block=instance.vpc_subnet,
    vpc_peering_connection_id=aws_vpc_peering.id,
    opts = pulumi.ResourceOptions(depends_on=[vpc_accept_peering]))

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"github.com/pulumi/pulumi-cloudamqp/sdk/v3/go/cloudamqp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// CloudAMQP - new instance, need to be created with a vpc
		instance, err := cloudamqp.NewInstance(ctx, "instance", &cloudamqp.InstanceArgs{
			Name:   pulumi.String("terraform-vpc-accepter"),
			Plan:   pulumi.String("penguin-1"),
			Region: pulumi.String("amazon-web-services::us-east-1"),
			Tags: pulumi.StringArray{
				pulumi.String("terraform"),
			},
			VpcSubnet: pulumi.String("10.40.72.0/24"),
		})
		if err != nil {
			return err
		}
		// CloudAMQP - Extract vpc information
		vpcInfo := instance.ID().ApplyT(func(id string) (cloudamqp.GetVpcInfoResult, error) {
			return cloudamqp.GetVpcInfoResult(interface{}(cloudamqp.GetVpcInfo(ctx, &cloudamqp.GetVpcInfoArgs{
				InstanceId: pulumi.IntRef(pulumi.IntRef(int(id))),
			}, nil))), nil
		}).(cloudamqp.GetVpcInfoResultOutput)
		// AWS - retrieve instance to get subnet identifier
		awsInstance, err := aws.Instance(ctx, map[string]interface{}{
			"instanceTags": map[string]interface{}{
				"name": awsInstanceName,
			},
		}, nil)
		if err != nil {
			return err
		}
		// AWS - retrieve subnet
		subnet, err := aws.Subnet(ctx, map[string]interface{}{
			"id": awsInstance.SubnetId,
		}, nil)
		if err != nil {
			return err
		}
		// AWS - Create peering request
		awsVpcPeering, err := aws.NewVpcPeeringConnection(ctx, "aws_vpc_peering", &aws.VpcPeeringConnectionArgs{
			VpcId:       subnet.VpcId,
			PeerVpcId:   vpcInfo.ID(),
			PeerOwnerId: vpcInfo.OwnerId,
			Tags: map[string]interface{}{
				"name": awsPeeringName,
			},
		})
		if err != nil {
			return err
		}
		// CloudAMQP - accept the peering request
		vpcAcceptPeering, err := cloudamqp.NewVpcPeering(ctx, "vpc_accept_peering", &cloudamqp.VpcPeeringArgs{
			InstanceId: instance.ID(),
			PeeringId:  awsVpcPeering.Id,
		})
		if err != nil {
			return err
		}
		// AWS - retrieve the route table created in AWS
		routeTable, err := aws.RouteTable(ctx, map[string]interface{}{
			"vpcId": subnet.VpcId,
		}, nil)
		if err != nil {
			return err
		}
		// AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
		_, err = aws.NewRoute(ctx, "accepter_route", &aws.RouteArgs{
			RouteTableId:           routeTable.RouteTableId,
			DestinationCidrBlock:   instance.VpcSubnet,
			VpcPeeringConnectionId: awsVpcPeering.Id,
		}, pulumi.DependsOn([]pulumi.Resource{
			vpcAcceptPeering,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using CloudAmqp = Pulumi.CloudAmqp;

return await Deployment.RunAsync(() => 
{
    // CloudAMQP - new instance, need to be created with a vpc
    var instance = new CloudAmqp.Instance("instance", new()
    {
        Name = "terraform-vpc-accepter",
        Plan = "penguin-1",
        Region = "amazon-web-services::us-east-1",
        Tags = new[]
        {
            "terraform",
        },
        VpcSubnet = "10.40.72.0/24",
    });

    // CloudAMQP - Extract vpc information
    var vpcInfo = CloudAmqp.GetVpcInfo.Invoke(new()
    {
        InstanceId = instance.Id,
    });

    // AWS - retrieve instance to get subnet identifier
    var awsInstance = Aws.Index.Instance.Invoke(new()
    {
        InstanceTags = 
        {
            { "name", awsInstanceName },
        },
    });

    // AWS - retrieve subnet
    var subnet = Aws.Index.Subnet.Invoke(new()
    {
        Id = awsInstance.SubnetId,
    });

    // AWS - Create peering request
    var awsVpcPeering = new Aws.Index.VpcPeeringConnection("aws_vpc_peering", new()
    {
        VpcId = subnet.VpcId,
        PeerVpcId = vpcInfo.Apply(getVpcInfoResult => getVpcInfoResult.Id),
        PeerOwnerId = vpcInfo.Apply(getVpcInfoResult => getVpcInfoResult.OwnerId),
        Tags = 
        {
            { "name", awsPeeringName },
        },
    });

    // CloudAMQP - accept the peering request
    var vpcAcceptPeering = new CloudAmqp.VpcPeering("vpc_accept_peering", new()
    {
        InstanceId = instance.Id,
        PeeringId = awsVpcPeering.Id,
    });

    // AWS - retrieve the route table created in AWS
    var routeTable = Aws.Index.RouteTable.Invoke(new()
    {
        VpcId = subnet.VpcId,
    });

    // AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
    var accepterRoute = new Aws.Index.Route("accepter_route", new()
    {
        RouteTableId = routeTable.RouteTableId,
        DestinationCidrBlock = instance.VpcSubnet,
        VpcPeeringConnectionId = awsVpcPeering.Id,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpcAcceptPeering,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cloudamqp.Instance;
import com.pulumi.cloudamqp.InstanceArgs;
import com.pulumi.cloudamqp.CloudamqpFunctions;
import com.pulumi.cloudamqp.inputs.GetVpcInfoArgs;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.VpcPeeringConnection;
import com.pulumi.aws.VpcPeeringConnectionArgs;
import com.pulumi.cloudamqp.VpcPeering;
import com.pulumi.cloudamqp.VpcPeeringArgs;
import com.pulumi.aws.Route;
import com.pulumi.aws.RouteArgs;
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) {
        // CloudAMQP - new instance, need to be created with a vpc
        var instance = new Instance("instance", InstanceArgs.builder()
            .name("terraform-vpc-accepter")
            .plan("penguin-1")
            .region("amazon-web-services::us-east-1")
            .tags("terraform")
            .vpcSubnet("10.40.72.0/24")
            .build());

        // CloudAMQP - Extract vpc information
        final var vpcInfo = instance.id().applyValue(_id -> CloudamqpFunctions.getVpcInfo(GetVpcInfoArgs.builder()
            .instanceId(_id)
            .build()));

        // AWS - retrieve instance to get subnet identifier
        final var awsInstance = AwsFunctions.Instance(Map.of("instanceTags", Map.of("name", awsInstanceName)));

        // AWS - retrieve subnet
        final var subnet = AwsFunctions.Subnet(Map.of("id", awsInstance.subnetId()));

        // AWS - Create peering request
        var awsVpcPeering = new VpcPeeringConnection("awsVpcPeering", VpcPeeringConnectionArgs.builder()
            .vpcId(subnet.vpcId())
            .peerVpcId(vpcInfo.id())
            .peerOwnerId(vpcInfo.ownerId())
            .tags(Map.of("name", awsPeeringName))
            .build());

        // CloudAMQP - accept the peering request
        var vpcAcceptPeering = new VpcPeering("vpcAcceptPeering", VpcPeeringArgs.builder()
            .instanceId(instance.id())
            .peeringId(awsVpcPeering.id())
            .build());

        // AWS - retrieve the route table created in AWS
        final var routeTable = AwsFunctions.RouteTable(Map.of("vpcId", subnet.vpcId()));

        // AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
        var accepterRoute = new Route("accepterRoute", RouteArgs.builder()
            .routeTableId(routeTable.routeTableId())
            .destinationCidrBlock(instance.vpcSubnet())
            .vpcPeeringConnectionId(awsVpcPeering.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(vpcAcceptPeering))
                .build());

    }
}

resources:
  # CloudAMQP - new instance, need to be created with a vpc
  instance:
    type: cloudamqp:Instance
    properties:
      name: terraform-vpc-accepter
      plan: penguin-1
      region: amazon-web-services::us-east-1
      tags:
        - terraform
      vpcSubnet: 10.40.72.0/24
  # AWS - Create peering request
  awsVpcPeering:
    type: aws:VpcPeeringConnection
    name: aws_vpc_peering
    properties:
      vpcId: ${subnet.vpcId}
      peerVpcId: ${vpcInfo.id}
      peerOwnerId: ${vpcInfo.ownerId}
      tags:
        name: ${awsPeeringName}
  # CloudAMQP - accept the peering request
  vpcAcceptPeering:
    type: cloudamqp:VpcPeering
    name: vpc_accept_peering
    properties:
      instanceId: ${instance.id}
      peeringId: ${awsVpcPeering.id}
  # AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
  accepterRoute:
    type: aws:Route
    name: accepter_route
    properties:
      routeTableId: ${routeTable.routeTableId}
      destinationCidrBlock: ${instance.vpcSubnet}
      vpcPeeringConnectionId: ${awsVpcPeering.id}
    options:
      dependsOn:
        - ${vpcAcceptPeering}
variables:
  # CloudAMQP - Extract vpc information
  vpcInfo:
    fn::invoke:
      function: cloudamqp:getVpcInfo
      arguments:
        instanceId: ${instance.id}
  # AWS - retrieve instance to get subnet identifier
  awsInstance:
    fn::invoke:
      function: aws:Instance
      arguments:
        instanceTags:
          name: ${awsInstanceName}
  # AWS - retrieve subnet
  subnet:
    fn::invoke:
      function: aws:Subnet
      arguments:
        id: ${awsInstance.subnetId}
  # AWS - retrieve the route table created in AWS
  routeTable:
    fn::invoke:
      function: aws:RouteTable
      arguments:
        vpcId: ${subnet.vpcId}

AWS VPC peering from [v1.16.0] (Managed VPC)

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as cloudamqp from "@pulumi/cloudamqp";

// CloudAMQP - Managed VPC resource
const vpc = new cloudamqp.Vpc("vpc", {
    name: "<VPC name>",
    region: "amazon-web-services::us-east-1",
    subnet: "10.56.72.0/24",
    tags: ["terraform"],
});
// CloudAMQP - new instance, need to be created with a vpc
const instance = new cloudamqp.Instance("instance", {
    name: "terraform-vpc-accepter",
    plan: "penguin-1",
    region: "amazon-web-services::us-east-1",
    tags: ["terraform"],
    vpcId: vpc.id,
    keepAssociatedVpc: true,
});
// CloudAMQP - Extract vpc information
const vpcInfo = cloudamqp.getVpcInfoOutput({
    vpcId: vpc.id,
});
// AWS - retrieve instance to get subnet identifier
const awsInstance = aws.index.Instance({
    instanceTags: {
        name: awsInstanceName,
    },
});
// AWS - retrieve subnet
const subnet = aws.index.Subnet({
    id: awsInstance.subnetId,
});
// AWS - Create peering request
const awsVpcPeering = new aws.index.VpcPeeringConnection("aws_vpc_peering", {
    vpcId: subnet.vpcId,
    peerVpcId: vpcInfo.id,
    peerOwnerId: vpcInfo.ownerId,
    tags: {
        name: awsPeeringName,
    },
});
// CloudAMQP - accept the peering request
const vpcAcceptPeering = new cloudamqp.VpcPeering("vpc_accept_peering", {
    vpcId: vpc.id,
    peeringId: awsVpcPeering.id,
    sleep: 30,
    timeout: 600,
});
// AWS - retrieve the route table created in AWS
const routeTable = aws.index.RouteTable({
    vpcId: subnet.vpcId,
});
// AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
const accepterRoute = new aws.index.Route("accepter_route", {
    routeTableId: routeTable.routeTableId,
    destinationCidrBlock: instance.vpcSubnet,
    vpcPeeringConnectionId: awsVpcPeering.id,
}, {
    dependsOn: [vpcAcceptPeering],
});

import pulumi
import pulumi_aws as aws
import pulumi_cloudamqp as cloudamqp

# CloudAMQP - Managed VPC resource
vpc = cloudamqp.Vpc("vpc",
    name="<VPC name>",
    region="amazon-web-services::us-east-1",
    subnet="10.56.72.0/24",
    tags=["terraform"])
# CloudAMQP - new instance, need to be created with a vpc
instance = cloudamqp.Instance("instance",
    name="terraform-vpc-accepter",
    plan="penguin-1",
    region="amazon-web-services::us-east-1",
    tags=["terraform"],
    vpc_id=vpc.id,
    keep_associated_vpc=True)
# CloudAMQP - Extract vpc information
vpc_info = cloudamqp.get_vpc_info_output(vpc_id=vpc.id)
# AWS - retrieve instance to get subnet identifier
aws_instance = aws.index.instance(instance_tags={
    "name": aws_instance_name,
})
# AWS - retrieve subnet
subnet = aws.index.subnet(id=aws_instance["subnetId"])
# AWS - Create peering request
aws_vpc_peering = aws.index.VpcPeeringConnection("aws_vpc_peering",
    vpc_id=subnet.vpc_id,
    peer_vpc_id=vpc_info.id,
    peer_owner_id=vpc_info.owner_id,
    tags={
        name: aws_peering_name,
    })
# CloudAMQP - accept the peering request
vpc_accept_peering = cloudamqp.VpcPeering("vpc_accept_peering",
    vpc_id=vpc.id,
    peering_id=aws_vpc_peering["id"],
    sleep=30,
    timeout=600)
# AWS - retrieve the route table created in AWS
route_table = aws.index.route_table(vpc_id=subnet["vpcId"])
# AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
accepter_route = aws.index.Route("accepter_route",
    route_table_id=route_table.route_table_id,
    destination_cidr_block=instance.vpc_subnet,
    vpc_peering_connection_id=aws_vpc_peering.id,
    opts = pulumi.ResourceOptions(depends_on=[vpc_accept_peering]))

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"github.com/pulumi/pulumi-cloudamqp/sdk/v3/go/cloudamqp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// CloudAMQP - Managed VPC resource
		vpc, err := cloudamqp.NewVpc(ctx, "vpc", &cloudamqp.VpcArgs{
			Name:   pulumi.String("<VPC name>"),
			Region: pulumi.String("amazon-web-services::us-east-1"),
			Subnet: pulumi.String("10.56.72.0/24"),
			Tags: pulumi.StringArray{
				pulumi.String("terraform"),
			},
		})
		if err != nil {
			return err
		}
		// CloudAMQP - new instance, need to be created with a vpc
		instance, err := cloudamqp.NewInstance(ctx, "instance", &cloudamqp.InstanceArgs{
			Name:   pulumi.String("terraform-vpc-accepter"),
			Plan:   pulumi.String("penguin-1"),
			Region: pulumi.String("amazon-web-services::us-east-1"),
			Tags: pulumi.StringArray{
				pulumi.String("terraform"),
			},
			VpcId:             vpc.ID(),
			KeepAssociatedVpc: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// CloudAMQP - Extract vpc information
		vpcInfo := cloudamqp.GetVpcInfoOutput(ctx, cloudamqp.GetVpcInfoOutputArgs{
			VpcId: vpc.ID(),
		}, nil)
		// AWS - retrieve instance to get subnet identifier
		awsInstance, err := aws.Instance(ctx, map[string]interface{}{
			"instanceTags": map[string]interface{}{
				"name": awsInstanceName,
			},
		}, nil)
		if err != nil {
			return err
		}
		// AWS - retrieve subnet
		subnet, err := aws.Subnet(ctx, map[string]interface{}{
			"id": awsInstance.SubnetId,
		}, nil)
		if err != nil {
			return err
		}
		// AWS - Create peering request
		awsVpcPeering, err := aws.NewVpcPeeringConnection(ctx, "aws_vpc_peering", &aws.VpcPeeringConnectionArgs{
			VpcId:       subnet.VpcId,
			PeerVpcId:   vpcInfo.ID(),
			PeerOwnerId: vpcInfo.OwnerId,
			Tags: map[string]interface{}{
				"name": awsPeeringName,
			},
		})
		if err != nil {
			return err
		}
		// CloudAMQP - accept the peering request
		vpcAcceptPeering, err := cloudamqp.NewVpcPeering(ctx, "vpc_accept_peering", &cloudamqp.VpcPeeringArgs{
			VpcId:     vpc.ID(),
			PeeringId: awsVpcPeering.Id,
			Sleep:     pulumi.Int(30),
			Timeout:   pulumi.Int(600),
		})
		if err != nil {
			return err
		}
		// AWS - retrieve the route table created in AWS
		routeTable, err := aws.RouteTable(ctx, map[string]interface{}{
			"vpcId": subnet.VpcId,
		}, nil)
		if err != nil {
			return err
		}
		// AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
		_, err = aws.NewRoute(ctx, "accepter_route", &aws.RouteArgs{
			RouteTableId:           routeTable.RouteTableId,
			DestinationCidrBlock:   instance.VpcSubnet,
			VpcPeeringConnectionId: awsVpcPeering.Id,
		}, pulumi.DependsOn([]pulumi.Resource{
			vpcAcceptPeering,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using CloudAmqp = Pulumi.CloudAmqp;

return await Deployment.RunAsync(() => 
{
    // CloudAMQP - Managed VPC resource
    var vpc = new CloudAmqp.Vpc("vpc", new()
    {
        Name = "<VPC name>",
        Region = "amazon-web-services::us-east-1",
        Subnet = "10.56.72.0/24",
        Tags = new[]
        {
            "terraform",
        },
    });

    // CloudAMQP - new instance, need to be created with a vpc
    var instance = new CloudAmqp.Instance("instance", new()
    {
        Name = "terraform-vpc-accepter",
        Plan = "penguin-1",
        Region = "amazon-web-services::us-east-1",
        Tags = new[]
        {
            "terraform",
        },
        VpcId = vpc.Id,
        KeepAssociatedVpc = true,
    });

    // CloudAMQP - Extract vpc information
    var vpcInfo = CloudAmqp.GetVpcInfo.Invoke(new()
    {
        VpcId = vpc.Id,
    });

    // AWS - retrieve instance to get subnet identifier
    var awsInstance = Aws.Index.Instance.Invoke(new()
    {
        InstanceTags = 
        {
            { "name", awsInstanceName },
        },
    });

    // AWS - retrieve subnet
    var subnet = Aws.Index.Subnet.Invoke(new()
    {
        Id = awsInstance.SubnetId,
    });

    // AWS - Create peering request
    var awsVpcPeering = new Aws.Index.VpcPeeringConnection("aws_vpc_peering", new()
    {
        VpcId = subnet.VpcId,
        PeerVpcId = vpcInfo.Apply(getVpcInfoResult => getVpcInfoResult.Id),
        PeerOwnerId = vpcInfo.Apply(getVpcInfoResult => getVpcInfoResult.OwnerId),
        Tags = 
        {
            { "name", awsPeeringName },
        },
    });

    // CloudAMQP - accept the peering request
    var vpcAcceptPeering = new CloudAmqp.VpcPeering("vpc_accept_peering", new()
    {
        VpcId = vpc.Id,
        PeeringId = awsVpcPeering.Id,
        Sleep = 30,
        Timeout = 600,
    });

    // AWS - retrieve the route table created in AWS
    var routeTable = Aws.Index.RouteTable.Invoke(new()
    {
        VpcId = subnet.VpcId,
    });

    // AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
    var accepterRoute = new Aws.Index.Route("accepter_route", new()
    {
        RouteTableId = routeTable.RouteTableId,
        DestinationCidrBlock = instance.VpcSubnet,
        VpcPeeringConnectionId = awsVpcPeering.Id,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpcAcceptPeering,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cloudamqp.Vpc;
import com.pulumi.cloudamqp.VpcArgs;
import com.pulumi.cloudamqp.Instance;
import com.pulumi.cloudamqp.InstanceArgs;
import com.pulumi.cloudamqp.CloudamqpFunctions;
import com.pulumi.cloudamqp.inputs.GetVpcInfoArgs;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.VpcPeeringConnection;
import com.pulumi.aws.VpcPeeringConnectionArgs;
import com.pulumi.cloudamqp.VpcPeering;
import com.pulumi.cloudamqp.VpcPeeringArgs;
import com.pulumi.aws.Route;
import com.pulumi.aws.RouteArgs;
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) {
        // CloudAMQP - Managed VPC resource
        var vpc = new Vpc("vpc", VpcArgs.builder()
            .name("<VPC name>")
            .region("amazon-web-services::us-east-1")
            .subnet("10.56.72.0/24")
            .tags("terraform")
            .build());

        // CloudAMQP - new instance, need to be created with a vpc
        var instance = new Instance("instance", InstanceArgs.builder()
            .name("terraform-vpc-accepter")
            .plan("penguin-1")
            .region("amazon-web-services::us-east-1")
            .tags("terraform")
            .vpcId(vpc.id())
            .keepAssociatedVpc(true)
            .build());

        // CloudAMQP - Extract vpc information
        final var vpcInfo = CloudamqpFunctions.getVpcInfo(GetVpcInfoArgs.builder()
            .vpcId(vpc.id())
            .build());

        // AWS - retrieve instance to get subnet identifier
        final var awsInstance = AwsFunctions.Instance(Map.of("instanceTags", Map.of("name", awsInstanceName)));

        // AWS - retrieve subnet
        final var subnet = AwsFunctions.Subnet(Map.of("id", awsInstance.subnetId()));

        // AWS - Create peering request
        var awsVpcPeering = new VpcPeeringConnection("awsVpcPeering", VpcPeeringConnectionArgs.builder()
            .vpcId(subnet.vpcId())
            .peerVpcId(vpcInfo.id())
            .peerOwnerId(vpcInfo.ownerId())
            .tags(Map.of("name", awsPeeringName))
            .build());

        // CloudAMQP - accept the peering request
        var vpcAcceptPeering = new VpcPeering("vpcAcceptPeering", VpcPeeringArgs.builder()
            .vpcId(vpc.id())
            .peeringId(awsVpcPeering.id())
            .sleep(30)
            .timeout(600)
            .build());

        // AWS - retrieve the route table created in AWS
        final var routeTable = AwsFunctions.RouteTable(Map.of("vpcId", subnet.vpcId()));

        // AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
        var accepterRoute = new Route("accepterRoute", RouteArgs.builder()
            .routeTableId(routeTable.routeTableId())
            .destinationCidrBlock(instance.vpcSubnet())
            .vpcPeeringConnectionId(awsVpcPeering.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(vpcAcceptPeering))
                .build());

    }
}

resources:
  # CloudAMQP - Managed VPC resource
  vpc:
    type: cloudamqp:Vpc
    properties:
      name: <VPC name>
      region: amazon-web-services::us-east-1
      subnet: 10.56.72.0/24
      tags:
        - terraform
  # CloudAMQP - new instance, need to be created with a vpc
  instance:
    type: cloudamqp:Instance
    properties:
      name: terraform-vpc-accepter
      plan: penguin-1
      region: amazon-web-services::us-east-1
      tags:
        - terraform
      vpcId: ${vpc.id}
      keepAssociatedVpc: true
  # AWS - Create peering request
  awsVpcPeering:
    type: aws:VpcPeeringConnection
    name: aws_vpc_peering
    properties:
      vpcId: ${subnet.vpcId}
      peerVpcId: ${vpcInfo.id}
      peerOwnerId: ${vpcInfo.ownerId}
      tags:
        name: ${awsPeeringName}
  # CloudAMQP - accept the peering request
  vpcAcceptPeering:
    type: cloudamqp:VpcPeering
    name: vpc_accept_peering
    properties:
      vpcId: ${vpc.id}
      peeringId: ${awsVpcPeering.id}
      sleep: 30
      timeout: 600
  # AWS - Once the peering request is accepted, configure routing table on accepter to allow traffic
  accepterRoute:
    type: aws:Route
    name: accepter_route
    properties:
      routeTableId: ${routeTable.routeTableId}
      destinationCidrBlock: ${instance.vpcSubnet}
      vpcPeeringConnectionId: ${awsVpcPeering.id}
    options:
      dependsOn:
        - ${vpcAcceptPeering}
variables:
  # CloudAMQP - Extract vpc information
  vpcInfo:
    fn::invoke:
      function: cloudamqp:getVpcInfo
      arguments:
        vpcId: ${vpc.id}
  # AWS - retrieve instance to get subnet identifier
  awsInstance:
    fn::invoke:
      function: aws:Instance
      arguments:
        instanceTags:
          name: ${awsInstanceName}
  # AWS - retrieve subnet
  subnet:
    fn::invoke:
      function: aws:Subnet
      arguments:
        id: ${awsInstance.subnetId}
  # AWS - retrieve the route table created in AWS
  routeTable:
    fn::invoke:
      function: aws:RouteTable
      arguments:
        vpcId: ${subnet.vpcId}

With Additional Firewall Rules

VPC peering before v1.16.0

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as cloudamqp from "@pulumi/cloudamqp";

// AWS - retrieve subnet
const subnet = aws.index.Subnet({
    id: awsInstance.subnetId,
});
// CloudAMQP - accept the peering request
const vpcAcceptPeering = new cloudamqp.VpcPeering("vpc_accept_peering", {
    instanceId: instance.id,
    peeringId: awsVpcPeering.id,
});
// Firewall rules
const firewallSettings = new cloudamqp.SecurityFirewall("firewall_settings", {
    instanceId: instance.id,
    rules: [
        {
            ip: awsInstance.subnetId,
            ports: [
                15672,
                5552,
                5551,
            ],
            services: [
                "AMQP",
                "AMQPS",
            ],
            description: "VPC peering for <NETWORK>",
        },
        {
            ip: "192.168.0.0/24",
            ports: [
                4567,
                4568,
            ],
            services: [
                "AMQP",
                "AMQPS",
                "HTTPS",
            ],
        },
    ],
}, {
    dependsOn: [vpcAcceptPeering],
});

import pulumi
import pulumi_aws as aws
import pulumi_cloudamqp as cloudamqp

# AWS - retrieve subnet
subnet = aws.index.subnet(id=aws_instance["subnetId"])
# CloudAMQP - accept the peering request
vpc_accept_peering = cloudamqp.VpcPeering("vpc_accept_peering",
    instance_id=instance["id"],
    peering_id=aws_vpc_peering["id"])
# Firewall rules
firewall_settings = cloudamqp.SecurityFirewall("firewall_settings",
    instance_id=instance["id"],
    rules=[
        {
            "ip": aws_instance["subnetId"],
            "ports": [
                15672,
                5552,
                5551,
            ],
            "services": [
                "AMQP",
                "AMQPS",
            ],
            "description": "VPC peering for <NETWORK>",
        },
        {
            "ip": "192.168.0.0/24",
            "ports": [
                4567,
                4568,
            ],
            "services": [
                "AMQP",
                "AMQPS",
                "HTTPS",
            ],
        },
    ],
    opts = pulumi.ResourceOptions(depends_on=[vpc_accept_peering]))

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"github.com/pulumi/pulumi-cloudamqp/sdk/v3/go/cloudamqp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// AWS - retrieve subnet
		_, err := aws.Subnet(ctx, map[string]interface{}{
			"id": awsInstance.SubnetId,
		}, nil)
		if err != nil {
			return err
		}
		// CloudAMQP - accept the peering request
		vpcAcceptPeering, err := cloudamqp.NewVpcPeering(ctx, "vpc_accept_peering", &cloudamqp.VpcPeeringArgs{
			InstanceId: pulumi.Any(instance.Id),
			PeeringId:  pulumi.Any(awsVpcPeering.Id),
		})
		if err != nil {
			return err
		}
		// Firewall rules
		_, err = cloudamqp.NewSecurityFirewall(ctx, "firewall_settings", &cloudamqp.SecurityFirewallArgs{
			InstanceId: pulumi.Any(instance.Id),
			Rules: cloudamqp.SecurityFirewallRuleArray{
				&cloudamqp.SecurityFirewallRuleArgs{
					Ip: pulumi.Any(awsInstance.SubnetId),
					Ports: pulumi.IntArray{
						pulumi.Int(15672),
						pulumi.Int(5552),
						pulumi.Int(5551),
					},
					Services: pulumi.StringArray{
						pulumi.String("AMQP"),
						pulumi.String("AMQPS"),
					},
					Description: pulumi.String("VPC peering for <NETWORK>"),
				},
				&cloudamqp.SecurityFirewallRuleArgs{
					Ip: pulumi.String("192.168.0.0/24"),
					Ports: pulumi.IntArray{
						pulumi.Int(4567),
						pulumi.Int(4568),
					},
					Services: pulumi.StringArray{
						pulumi.String("AMQP"),
						pulumi.String("AMQPS"),
						pulumi.String("HTTPS"),
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			vpcAcceptPeering,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using CloudAmqp = Pulumi.CloudAmqp;

return await Deployment.RunAsync(() => 
{
    // AWS - retrieve subnet
    var subnet = Aws.Index.Subnet.Invoke(new()
    {
        Id = awsInstance.SubnetId,
    });

    // CloudAMQP - accept the peering request
    var vpcAcceptPeering = new CloudAmqp.VpcPeering("vpc_accept_peering", new()
    {
        InstanceId = instance.Id,
        PeeringId = awsVpcPeering.Id,
    });

    // Firewall rules
    var firewallSettings = new CloudAmqp.SecurityFirewall("firewall_settings", new()
    {
        InstanceId = instance.Id,
        Rules = new[]
        {
            new CloudAmqp.Inputs.SecurityFirewallRuleArgs
            {
                Ip = awsInstance.SubnetId,
                Ports = new[]
                {
                    15672,
                    5552,
                    5551,
                },
                Services = new[]
                {
                    "AMQP",
                    "AMQPS",
                },
                Description = "VPC peering for <NETWORK>",
            },
            new CloudAmqp.Inputs.SecurityFirewallRuleArgs
            {
                Ip = "192.168.0.0/24",
                Ports = new[]
                {
                    4567,
                    4568,
                },
                Services = new[]
                {
                    "AMQP",
                    "AMQPS",
                    "HTTPS",
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpcAcceptPeering,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.cloudamqp.VpcPeering;
import com.pulumi.cloudamqp.VpcPeeringArgs;
import com.pulumi.cloudamqp.SecurityFirewall;
import com.pulumi.cloudamqp.SecurityFirewallArgs;
import com.pulumi.cloudamqp.inputs.SecurityFirewallRuleArgs;
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) {
        // AWS - retrieve subnet
        final var subnet = AwsFunctions.Subnet(Map.of("id", awsInstance.subnetId()));

        // CloudAMQP - accept the peering request
        var vpcAcceptPeering = new VpcPeering("vpcAcceptPeering", VpcPeeringArgs.builder()
            .instanceId(instance.id())
            .peeringId(awsVpcPeering.id())
            .build());

        // Firewall rules
        var firewallSettings = new SecurityFirewall("firewallSettings", SecurityFirewallArgs.builder()
            .instanceId(instance.id())
            .rules(            
                SecurityFirewallRuleArgs.builder()
                    .ip(awsInstance.subnetId())
                    .ports(                    
                        15672,
                        5552,
                        5551)
                    .services(                    
                        "AMQP",
                        "AMQPS")
                    .description("VPC peering for <NETWORK>")
                    .build(),
                SecurityFirewallRuleArgs.builder()
                    .ip("192.168.0.0/24")
                    .ports(                    
                        4567,
                        4568)
                    .services(                    
                        "AMQP",
                        "AMQPS",
                        "HTTPS")
                    .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(vpcAcceptPeering)
                .build());

    }
}

resources:
  # CloudAMQP - accept the peering request
  vpcAcceptPeering:
    type: cloudamqp:VpcPeering
    name: vpc_accept_peering
    properties:
      instanceId: ${instance.id}
      peeringId: ${awsVpcPeering.id}
  # Firewall rules
  firewallSettings:
    type: cloudamqp:SecurityFirewall
    name: firewall_settings
    properties:
      instanceId: ${instance.id}
      rules:
        - ip: ${awsInstance.subnetId}
          ports:
            - 15672
            - 5552
            - 5551
          services:
            - AMQP
            - AMQPS
          description: VPC peering for <NETWORK>
        - ip: 192.168.0.0/24
          ports:
            - 4567
            - 4568
          services:
            - AMQP
            - AMQPS
            - HTTPS
    options:
      dependsOn:
        - ${vpcAcceptPeering}
variables:
  # AWS - retrieve subnet
  subnet:
    fn::invoke:
      function: aws:Subnet
      arguments:
        id: ${awsInstance.subnetId}

VPC peering from [v1.16.0] (Managed VPC)

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as cloudamqp from "@pulumi/cloudamqp";

// AWS - retrieve subnet
const subnet = aws.index.Subnet({
    id: awsInstance.subnetId,
});
// CloudAMQP - accept the peering request
const vpcAcceptPeering = new cloudamqp.VpcPeering("vpc_accept_peering", {
    vpcId: vpc.id,
    peeringId: awsVpcPeering.id,
    sleep: 30,
    timeout: 600,
});
// AWS - VPC subnet for peering requester
const requesterVpc = aws.index.Vpc({
    id: subnet.vpcId,
});
// CloudAMQP - Managed firewall rules
const firewallSettings = new cloudamqp.SecurityFirewall("firewall_settings", {
    instanceId: instance.id,
    rules: [
        {
            ip: requesterVpc.cidrBlock,
            ports: [
                15672,
                5552,
                5551,
            ],
            services: [
                "AMQP",
                "AMQPS",
            ],
            description: "VPC peering for <NETWORK>",
        },
        {
            ip: "0.0.0.0/0",
            ports: [],
            services: ["HTTPS"],
            description: "MGMT interface",
        },
    ],
}, {
    dependsOn: [vpcAcceptPeering],
});

import pulumi
import pulumi_aws as aws
import pulumi_cloudamqp as cloudamqp

# AWS - retrieve subnet
subnet = aws.index.subnet(id=aws_instance["subnetId"])
# CloudAMQP - accept the peering request
vpc_accept_peering = cloudamqp.VpcPeering("vpc_accept_peering",
    vpc_id=vpc["id"],
    peering_id=aws_vpc_peering["id"],
    sleep=30,
    timeout=600)
# AWS - VPC subnet for peering requester
requester_vpc = aws.index.vpc(id=subnet["vpcId"])
# CloudAMQP - Managed firewall rules
firewall_settings = cloudamqp.SecurityFirewall("firewall_settings",
    instance_id=instance["id"],
    rules=[
        {
            "ip": requester_vpc["cidrBlock"],
            "ports": [
                15672,
                5552,
                5551,
            ],
            "services": [
                "AMQP",
                "AMQPS",
            ],
            "description": "VPC peering for <NETWORK>",
        },
        {
            "ip": "0.0.0.0/0",
            "ports": [],
            "services": ["HTTPS"],
            "description": "MGMT interface",
        },
    ],
    opts = pulumi.ResourceOptions(depends_on=[vpc_accept_peering]))

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"github.com/pulumi/pulumi-cloudamqp/sdk/v3/go/cloudamqp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// AWS - retrieve subnet
		subnet, err := aws.Subnet(ctx, map[string]interface{}{
			"id": awsInstance.SubnetId,
		}, nil)
		if err != nil {
			return err
		}
		// CloudAMQP - accept the peering request
		vpcAcceptPeering, err := cloudamqp.NewVpcPeering(ctx, "vpc_accept_peering", &cloudamqp.VpcPeeringArgs{
			VpcId:     pulumi.Any(vpc.Id),
			PeeringId: pulumi.Any(awsVpcPeering.Id),
			Sleep:     pulumi.Int(30),
			Timeout:   pulumi.Int(600),
		})
		if err != nil {
			return err
		}
		// AWS - VPC subnet for peering requester
		requesterVpc, err := aws.Vpc(ctx, map[string]interface{}{
			"id": subnet.VpcId,
		}, nil)
		if err != nil {
			return err
		}
		// CloudAMQP - Managed firewall rules
		_, err = cloudamqp.NewSecurityFirewall(ctx, "firewall_settings", &cloudamqp.SecurityFirewallArgs{
			InstanceId: pulumi.Any(instance.Id),
			Rules: cloudamqp.SecurityFirewallRuleArray{
				&cloudamqp.SecurityFirewallRuleArgs{
					Ip: pulumi.Any(requesterVpc.CidrBlock),
					Ports: pulumi.IntArray{
						pulumi.Int(15672),
						pulumi.Int(5552),
						pulumi.Int(5551),
					},
					Services: pulumi.StringArray{
						pulumi.String("AMQP"),
						pulumi.String("AMQPS"),
					},
					Description: pulumi.String("VPC peering for <NETWORK>"),
				},
				&cloudamqp.SecurityFirewallRuleArgs{
					Ip:    pulumi.String("0.0.0.0/0"),
					Ports: pulumi.IntArray{},
					Services: pulumi.StringArray{
						pulumi.String("HTTPS"),
					},
					Description: pulumi.String("MGMT interface"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			vpcAcceptPeering,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using CloudAmqp = Pulumi.CloudAmqp;

return await Deployment.RunAsync(() => 
{
    // AWS - retrieve subnet
    var subnet = Aws.Index.Subnet.Invoke(new()
    {
        Id = awsInstance.SubnetId,
    });

    // CloudAMQP - accept the peering request
    var vpcAcceptPeering = new CloudAmqp.VpcPeering("vpc_accept_peering", new()
    {
        VpcId = vpc.Id,
        PeeringId = awsVpcPeering.Id,
        Sleep = 30,
        Timeout = 600,
    });

    // AWS - VPC subnet for peering requester
    var requesterVpc = Aws.Index.Vpc.Invoke(new()
    {
        Id = subnet.VpcId,
    });

    // CloudAMQP - Managed firewall rules
    var firewallSettings = new CloudAmqp.SecurityFirewall("firewall_settings", new()
    {
        InstanceId = instance.Id,
        Rules = new[]
        {
            new CloudAmqp.Inputs.SecurityFirewallRuleArgs
            {
                Ip = requesterVpc.CidrBlock,
                Ports = new[]
                {
                    15672,
                    5552,
                    5551,
                },
                Services = new[]
                {
                    "AMQP",
                    "AMQPS",
                },
                Description = "VPC peering for <NETWORK>",
            },
            new CloudAmqp.Inputs.SecurityFirewallRuleArgs
            {
                Ip = "0.0.0.0/0",
                Ports = new() { },
                Services = new[]
                {
                    "HTTPS",
                },
                Description = "MGMT interface",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpcAcceptPeering,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.cloudamqp.VpcPeering;
import com.pulumi.cloudamqp.VpcPeeringArgs;
import com.pulumi.cloudamqp.SecurityFirewall;
import com.pulumi.cloudamqp.SecurityFirewallArgs;
import com.pulumi.cloudamqp.inputs.SecurityFirewallRuleArgs;
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) {
        // AWS - retrieve subnet
        final var subnet = AwsFunctions.Subnet(Map.of("id", awsInstance.subnetId()));

        // CloudAMQP - accept the peering request
        var vpcAcceptPeering = new VpcPeering("vpcAcceptPeering", VpcPeeringArgs.builder()
            .vpcId(vpc.id())
            .peeringId(awsVpcPeering.id())
            .sleep(30)
            .timeout(600)
            .build());

        // AWS - VPC subnet for peering requester
        final var requesterVpc = AwsFunctions.Vpc(Map.of("id", subnet.vpcId()));

        // CloudAMQP - Managed firewall rules
        var firewallSettings = new SecurityFirewall("firewallSettings", SecurityFirewallArgs.builder()
            .instanceId(instance.id())
            .rules(            
                SecurityFirewallRuleArgs.builder()
                    .ip(requesterVpc.cidrBlock())
                    .ports(                    
                        15672,
                        5552,
                        5551)
                    .services(                    
                        "AMQP",
                        "AMQPS")
                    .description("VPC peering for <NETWORK>")
                    .build(),
                SecurityFirewallRuleArgs.builder()
                    .ip("0.0.0.0/0")
                    .ports()
                    .services("HTTPS")
                    .description("MGMT interface")
                    .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(vpcAcceptPeering)
                .build());

    }
}

resources:
  # CloudAMQP - accept the peering request
  vpcAcceptPeering:
    type: cloudamqp:VpcPeering
    name: vpc_accept_peering
    properties:
      vpcId: ${vpc.id}
      peeringId: ${awsVpcPeering.id}
      sleep: 30
      timeout: 600
  # CloudAMQP - Managed firewall rules
  firewallSettings:
    type: cloudamqp:SecurityFirewall
    name: firewall_settings
    properties:
      instanceId: ${instance.id}
      rules:
        - ip: ${requesterVpc.cidrBlock}
          ports:
            - 15672
            - 5552
            - 5551
          services:
            - AMQP
            - AMQPS
          description: VPC peering for <NETWORK>
        - ip: 0.0.0.0/0
          ports: []
          services:
            - HTTPS
          description: MGMT interface
    options:
      dependsOn:
        - ${vpcAcceptPeering}
variables:
  # AWS - retrieve subnet
  subnet:
    fn::invoke:
      function: aws:Subnet
      arguments:
        id: ${awsInstance.subnetId}
  # AWS - VPC subnet for peering requester
  requesterVpc:
    fn::invoke:
      function: aws:Vpc
      arguments:
        id: ${subnet.vpcId}

Dependency

Before v1.16.0: This resource depends on CloudAMQP instance identifier, cloudamqp_instance.instance.id.

From v1.16.0: This resource depends on CloudAMQP managed VPC identifier, cloudamqp_vpc.vpc.id or instance identifier, cloudamqp_instance.instance.id.

Create VPC Peering with additional firewall rules

To create a VPC peering configuration with additional firewall rules, it’s required to chain the cloudamqp.SecurityFirewall resource to avoid parallel conflicting resource calls. You can do this by making the firewall resource depend on the VPC peering resource cloudamqp_vpc_peering.vpc_accept_peering.

Furthermore, since all firewall rules are overwritten, the otherwise automatically added rules for the VPC peering also needs to be added.

See example below.

Create VpcPeering Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new VpcPeering(name: string, args: VpcPeeringArgs, opts?: CustomResourceOptions);

@overload
def VpcPeering(resource_name: str,
               args: VpcPeeringArgs,
               opts: Optional[ResourceOptions] = None)

@overload
def VpcPeering(resource_name: str,
               opts: Optional[ResourceOptions] = None,
               peering_id: Optional[str] = None,
               instance_id: Optional[int] = None,
               sleep: Optional[int] = None,
               timeout: Optional[int] = None,
               vpc_id: Optional[str] = None)

func NewVpcPeering(ctx *Context, name string, args VpcPeeringArgs, opts ...ResourceOption) (*VpcPeering, error)

public VpcPeering(string name, VpcPeeringArgs args, CustomResourceOptions? opts = null)

public VpcPeering(String name, VpcPeeringArgs args)
public VpcPeering(String name, VpcPeeringArgs args, CustomResourceOptions options)

type: cloudamqp:VpcPeering
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name string: The unique name of the resource.
args VpcPeeringArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args VpcPeeringArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args VpcPeeringArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args VpcPeeringArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args VpcPeeringArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var vpcPeeringResource = new CloudAmqp.Index.VpcPeering("vpcPeeringResource", new()
{
    PeeringId = "string",
    InstanceId = 0,
    Sleep = 0,
    Timeout = 0,
    VpcId = "string",
});

example, err := cloudamqp.NewVpcPeering(ctx, "vpcPeeringResource", &cloudamqp.VpcPeeringArgs{
	PeeringId:  pulumi.String("string"),
	InstanceId: pulumi.Int(0),
	Sleep:      pulumi.Int(0),
	Timeout:    pulumi.Int(0),
	VpcId:      pulumi.String("string"),
})

var vpcPeeringResource = new VpcPeering("vpcPeeringResource", VpcPeeringArgs.builder()
    .peeringId("string")
    .instanceId(0)
    .sleep(0)
    .timeout(0)
    .vpcId("string")
    .build());

vpc_peering_resource = cloudamqp.VpcPeering("vpcPeeringResource",
    peering_id="string",
    instance_id=0,
    sleep=0,
    timeout=0,
    vpc_id="string")

const vpcPeeringResource = new cloudamqp.VpcPeering("vpcPeeringResource", {
    peeringId: "string",
    instanceId: 0,
    sleep: 0,
    timeout: 0,
    vpcId: "string",
});

type: cloudamqp:VpcPeering
properties:
    instanceId: 0
    peeringId: string
    sleep: 0
    timeout: 0
    vpcId: string

VpcPeering Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The VpcPeering resource accepts the following input properties:

PeeringId string

Peering identifier created by AW peering request.

InstanceId int

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

Sleep int

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

Timeout int

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

VpcId string

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

PeeringId string

Peering identifier created by AW peering request.

InstanceId int

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

Sleep int

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

Timeout int

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

VpcId string

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

peeringId String

Peering identifier created by AW peering request.

instanceId Integer

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

sleep Integer

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

timeout Integer

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpcId String

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

peeringId string

Peering identifier created by AW peering request.

instanceId number

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

sleep number

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

timeout number

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpcId string

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

peering_id str

Peering identifier created by AW peering request.

instance_id int

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

sleep int

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

timeout int

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpc_id str

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

peeringId String

Peering identifier created by AW peering request.

instanceId Number

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

sleep Number

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

timeout Number

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpcId String

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

Outputs

All input properties are implicitly available as output properties. Additionally, the VpcPeering resource produces the following output properties:

Id string: The provider-assigned unique ID for this managed resource.
Status string: VPC peering status

Id string: The provider-assigned unique ID for this managed resource.
Status string: VPC peering status

id String: The provider-assigned unique ID for this managed resource.
status String: VPC peering status

id string: The provider-assigned unique ID for this managed resource.
status string: VPC peering status

id str: The provider-assigned unique ID for this managed resource.
status str: VPC peering status

id String: The provider-assigned unique ID for this managed resource.
status String: VPC peering status

Look up Existing VpcPeering Resource

Get an existing VpcPeering resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: VpcPeeringState, opts?: CustomResourceOptions): VpcPeering

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        instance_id: Optional[int] = None,
        peering_id: Optional[str] = None,
        sleep: Optional[int] = None,
        status: Optional[str] = None,
        timeout: Optional[int] = None,
        vpc_id: Optional[str] = None) -> VpcPeering

func GetVpcPeering(ctx *Context, name string, id IDInput, state *VpcPeeringState, opts ...ResourceOption) (*VpcPeering, error)

public static VpcPeering Get(string name, Input<string> id, VpcPeeringState? state, CustomResourceOptions? opts = null)

public static VpcPeering get(String name, Output<String> id, VpcPeeringState state, CustomResourceOptions options)

resources:  _:    type: cloudamqp:VpcPeering    get:      id: ${id}

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

InstanceId int

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

PeeringId string

Peering identifier created by AW peering request.

Sleep int

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

Status string

VPC peering status

Timeout int

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

VpcId string

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

InstanceId int

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

PeeringId string

Peering identifier created by AW peering request.

Sleep int

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

Status string

VPC peering status

Timeout int

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

VpcId string

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

instanceId Integer

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

peeringId String

Peering identifier created by AW peering request.

sleep Integer

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

status String

VPC peering status

timeout Integer

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpcId String

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

instanceId number

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

peeringId string

Peering identifier created by AW peering request.

sleep number

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

status string

VPC peering status

timeout number

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpcId string

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

instance_id int

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

peering_id str

Peering identifier created by AW peering request.

sleep int

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

status str

VPC peering status

timeout int

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpc_id str

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

instanceId Number

The CloudAMQP instance identifier.

Deprecated: from [v1.16.0], will be removed in next major version (v2.0)

peeringId String

Peering identifier created by AW peering request.

sleep Number

Configurable sleep time (seconds) between retries for accepting or removing peering. Default set to 60 seconds.

status String

VPC peering status

timeout Number

Configurable timeout time (seconds) for accepting or removing peering. Default set to 3600 seconds.

vpcId String

The managed VPC identifier.

Note: Available from [v1.16.0], will be required in next major version (v2.0)

Import

Before v1.32.2: Not possible to import this resource.

From v1.32.2: cloudamqp.VpcPeering can be imported while using the resource type, with CloudAMQP VPC identifier or instance identifier together with peering_id (CSV seperated).

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository: CloudAMQP pulumi/pulumi-cloudamqp
License: Apache-2.0
Notes: This Pulumi package is based on the cloudamqp Terraform Provider.

Viewing docs for CloudAMQP v3.27.1
published on Friday, Mar 20, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-cloudamqp

cloudamqp.VpcPeering

On this page

On this page

Example Usage

With Additional Firewall Rules

Dependency

Create VPC Peering with additional firewall rules

Create VpcPeering Resource

Constructor syntax

Parameters

Constructor example

VpcPeering Resource Properties

Inputs

Outputs

Look up Existing VpcPeering Resource

Import

Package Details

On this page

On this page