getRouteTables function

Future<GetRouteTablesResult> getRouteTables(
  1. GetRouteTablesArgs args, {
  2. InvokeOptions? options,
})

This resource can be useful for getting back a list of route table ids to be referenced elsewhere.

Example Usage

The following adds a route for a particular cidr block to every (private kops) route table in a specified vpc to use a particular vpc peering connection.

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

const rts = aws.ec2.getRouteTables({
    filters: [{
        name: "tag:kubernetes.io/kops/role",
        values: ["private*"],
    }],
    vpcId: vpcId,
});
const r: aws.ec2.Route[] = [];
rts.then(rts => rts.ids).length.apply(rangeBody => {
    for (let range = 0; range < rangeBody; range++) {
        r.push(new aws.ec2.Route(`r-${range}`, {
            routeTableId: rts.then(rts => rts.ids[range]),
            destinationCidrBlock: "10.0.0.0/22",
            vpcPeeringConnectionId: "pcx-0e9a7a9ecd137dc54",
        }));
    }
});
import pulumi
from typing import Any
import pulumi_aws as aws

rts = aws.ec2.get_route_tables(filters=[{
        "name": "tag:kubernetes.io/kops/role",
        "values": ["private*"],
    }],
    vpc_id=vpc_id)
r: list[aws.ec2.Route] = []
def create_r(range_body):
    for r_range in [{"value": i} for i in range(0, range_body)]:
        r.append(aws.ec2.Route(f"r-{r_range['value']}",
            route_table_id=rts.ids[r_range["value"]],
            destination_cidr_block="10.0.0.0/22",
            vpc_peering_connection_id="pcx-0e9a7a9ecd137dc54"))

(len(rts.ids)).apply(create_r)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var rts = Aws.Ec2.GetRouteTables.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetRouteTablesFilterInputArgs
            {
                Name = "tag:kubernetes.io/kops/role",
                Values = new[]
                {
                    "private*",
                },
            },
        },
        VpcId = vpcId,
    });

    var r = new List<Aws.Ec2.Route>();
    rts.Apply(getRouteTablesResult => getRouteTablesResult.Ids).Length().Apply(rangeBody =>
    {
        for (var rangeIndex = 0; rangeIndex < rangeBody; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            r.Add(new Aws.Ec2.Route($"r-{range.Value}", new()
            {
                RouteTableId = rts.Apply(getRouteTablesResult => getRouteTablesResult.Ids)[range.Value],
                DestinationCidrBlock = "10.0.0.0/22",
                VpcPeeringConnectionId = "pcx-0e9a7a9ecd137dc54",
            }));
        }
        return 0;
    });
});
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		rts, err := ec2.GetRouteTables(ctx, &ec2.GetRouteTablesArgs{
			Filters: []ec2.GetRouteTablesFilter{
				{
					Name: "tag:kubernetes.io/kops/role",
					Values: []string{
						"private*",
					},
				},
			},
			VpcId: pulumi.StringRef(vpcId),
		}, nil)
		if err != nil {
			return err
		}
		var r []*ec2.Route
		for index := 0; index < int(len(rts.Ids)); index++ {
			key0 := index
			val0 := index
			__res, err := ec2.NewRoute(ctx, fmt.Sprintf("r-%v", key0), &ec2.RouteArgs{
				RouteTableId:           pulumi.String(rts.Ids[val0]),
				DestinationCidrBlock:   pulumi.String("10.0.0.0/22"),
				VpcPeeringConnectionId: pulumi.String("pcx-0e9a7a9ecd137dc54"),
			})
			if err != nil {
				return err
			}
			r = append(r, __res)
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_ec2_getroutetables" "rts" {
  filters {
    name   = "tag:kubernetes.io/kops/role"
    values = ["private*"]
  }
  vpc_id = vpcId
}

resource "aws_ec2_route" "r" {
  count                     = length(data.aws_ec2_getroutetables.rts.ids)
  route_table_id            = data.aws_ec2_getroutetables.rts.ids[count.index]
  destination_cidr_block    = "10.0.0.0/22"
  vpc_peering_connection_id = "pcx-0e9a7a9ecd137dc54"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetRouteTablesArgs;
import com.pulumi.aws.ec2.inputs.GetRouteTablesFilterArgs;
import com.pulumi.aws.ec2.Route;
import com.pulumi.aws.ec2.RouteArgs;
import com.pulumi.codegen.internal.KeyedValue;
import java.util.ArrayList;
import java.util.Arrays;
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 rts = Ec2Functions.getRouteTables(GetRouteTablesArgs.builder()
            .filters(GetRouteTablesFilterArgs.builder()
                .name("tag:kubernetes.io/kops/role")
                .values("private*")
                .build())
            .vpcId(vpcId)
            .build());

        for (var i = 0; i < rts.ids().size(); i++) {
            new Route("r-" + i, RouteArgs.builder()
                .routeTableId(rts.ids()[range.value()])
                .destinationCidrBlock("10.0.0.0/22")
                .vpcPeeringConnectionId("pcx-0e9a7a9ecd137dc54")
                .build());


}
    }
}

args Arguments passed to this invoke. Arguments for getRouteTables. options Invoke options controlling this call.

Implementation

Future<GetRouteTablesResult> getRouteTables(
  GetRouteTablesArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:ec2/getRouteTables:getRouteTables',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetRouteTablesResult.fromMap(result);
}