opentelekomcloud.getVpcRouteTablesV1

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

const config = new pulumi.Config();
const vpcId = config.requireObject<any>("vpcId");
const routeTableId = config.requireObject<any>("routeTableId");
const subnetNetworkId = config.requireObject<any>("subnetNetworkId");
// get all route tables
const allRouteTables = opentelekomcloud.getVpcRouteTablesV1({});
// get route tables for specific vpc
const vpcRouteTables = opentelekomcloud.getVpcRouteTablesV1({
    vpcId: vpcId,
});
// get a list that includes single specific route table
const singleRouteTable = opentelekomcloud.getVpcRouteTablesV1({
    id: routeTableId,
});
// get a list of route table associated with a specific subnet
const subnetRouteTable = opentelekomcloud.getVpcRouteTablesV1({
    subnetId: subnetNetworkId,
});

import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

config = pulumi.Config()
vpc_id = config.require_object("vpcId")
route_table_id = config.require_object("routeTableId")
subnet_network_id = config.require_object("subnetNetworkId")
# get all route tables
all_route_tables = opentelekomcloud.get_vpc_route_tables_v1()
# get route tables for specific vpc
vpc_route_tables = opentelekomcloud.get_vpc_route_tables_v1(vpc_id=vpc_id)
# get a list that includes single specific route table
single_route_table = opentelekomcloud.get_vpc_route_tables_v1(id=route_table_id)
# get a list of route table associated with a specific subnet
subnet_route_table = opentelekomcloud.get_vpc_route_tables_v1(subnet_id=subnet_network_id)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"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, "")
		vpcId := cfg.RequireObject("vpcId")
		routeTableId := cfg.RequireObject("routeTableId")
		subnetNetworkId := cfg.RequireObject("subnetNetworkId")
		// get all route tables
		_, err := opentelekomcloud.GetVpcRouteTablesV1(ctx, &opentelekomcloud.GetVpcRouteTablesV1Args{}, nil)
		if err != nil {
			return err
		}
		// get route tables for specific vpc
		_, err = opentelekomcloud.GetVpcRouteTablesV1(ctx, &opentelekomcloud.GetVpcRouteTablesV1Args{
			VpcId: pulumi.StringRef(vpcId),
		}, nil)
		if err != nil {
			return err
		}
		// get a list that includes single specific route table
		_, err = opentelekomcloud.GetVpcRouteTablesV1(ctx, &opentelekomcloud.GetVpcRouteTablesV1Args{
			Id: pulumi.StringRef(routeTableId),
		}, nil)
		if err != nil {
			return err
		}
		// get a list of route table associated with a specific subnet
		_, err = opentelekomcloud.GetVpcRouteTablesV1(ctx, &opentelekomcloud.GetVpcRouteTablesV1Args{
			SubnetId: pulumi.StringRef(subnetNetworkId),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var vpcId = config.RequireObject<dynamic>("vpcId");
    var routeTableId = config.RequireObject<dynamic>("routeTableId");
    var subnetNetworkId = config.RequireObject<dynamic>("subnetNetworkId");
    // get all route tables
    var allRouteTables = Opentelekomcloud.GetVpcRouteTablesV1.Invoke();

    // get route tables for specific vpc
    var vpcRouteTables = Opentelekomcloud.GetVpcRouteTablesV1.Invoke(new()
    {
        VpcId = vpcId,
    });

    // get a list that includes single specific route table
    var singleRouteTable = Opentelekomcloud.GetVpcRouteTablesV1.Invoke(new()
    {
        Id = routeTableId,
    });

    // get a list of route table associated with a specific subnet
    var subnetRouteTable = Opentelekomcloud.GetVpcRouteTablesV1.Invoke(new()
    {
        SubnetId = subnetNetworkId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.OpentelekomcloudFunctions;
import com.pulumi.opentelekomcloud.inputs.GetVpcRouteTablesV1Args;
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 vpcId = config.get("vpcId");
        final var routeTableId = config.get("routeTableId");
        final var subnetNetworkId = config.get("subnetNetworkId");
        // get all route tables
        final var allRouteTables = OpentelekomcloudFunctions.getVpcRouteTablesV1(GetVpcRouteTablesV1Args.builder()
            .build());

        // get route tables for specific vpc
        final var vpcRouteTables = OpentelekomcloudFunctions.getVpcRouteTablesV1(GetVpcRouteTablesV1Args.builder()
            .vpcId(vpcId)
            .build());

        // get a list that includes single specific route table
        final var singleRouteTable = OpentelekomcloudFunctions.getVpcRouteTablesV1(GetVpcRouteTablesV1Args.builder()
            .id(routeTableId)
            .build());

        // get a list of route table associated with a specific subnet
        final var subnetRouteTable = OpentelekomcloudFunctions.getVpcRouteTablesV1(GetVpcRouteTablesV1Args.builder()
            .subnetId(subnetNetworkId)
            .build());

    }
}

configuration:
  vpcId:
    type: dynamic
  routeTableId:
    type: dynamic
  subnetNetworkId:
    type: dynamic
variables:
  # get all route tables
  allRouteTables:
    fn::invoke:
      function: opentelekomcloud:getVpcRouteTablesV1
      arguments: {}
  # get route tables for specific vpc
  vpcRouteTables:
    fn::invoke:
      function: opentelekomcloud:getVpcRouteTablesV1
      arguments:
        vpcId: ${vpcId}
  # get a list that includes single specific route table
  singleRouteTable:
    fn::invoke:
      function: opentelekomcloud:getVpcRouteTablesV1
      arguments:
        id: ${routeTableId}
  # get a list of route table associated with a specific subnet
  subnetRouteTable:
    fn::invoke:
      function: opentelekomcloud:getVpcRouteTablesV1
      arguments:
        subnetId: ${subnetNetworkId}

function getVpcRouteTablesV1(args: GetVpcRouteTablesV1Args, opts?: InvokeOptions): Promise<GetVpcRouteTablesV1Result>
function getVpcRouteTablesV1Output(args: GetVpcRouteTablesV1OutputArgs, opts?: InvokeOutputOptions): Output<GetVpcRouteTablesV1Result>

def get_vpc_route_tables_v1(id: Optional[str] = None,
                            subnet_id: Optional[str] = None,
                            vpc_id: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetVpcRouteTablesV1Result
def get_vpc_route_tables_v1_output(id: pulumi.Input[Optional[str]] = None,
                            subnet_id: pulumi.Input[Optional[str]] = None,
                            vpc_id: pulumi.Input[Optional[str]] = None,
                            opts: Optional[InvokeOutputOptions] = None) -> Output[GetVpcRouteTablesV1Result]

func GetVpcRouteTablesV1(ctx *Context, args *GetVpcRouteTablesV1Args, opts ...InvokeOption) (*GetVpcRouteTablesV1Result, error)
func GetVpcRouteTablesV1Output(ctx *Context, args *GetVpcRouteTablesV1OutputArgs, opts ...InvokeOption) GetVpcRouteTablesV1ResultOutput

public static class GetVpcRouteTablesV1 
{
    public static Task<GetVpcRouteTablesV1Result> InvokeAsync(GetVpcRouteTablesV1Args args, InvokeOptions? opts = null)
    public static Output<GetVpcRouteTablesV1Result> Invoke(GetVpcRouteTablesV1InvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetVpcRouteTablesV1Result> Invoke(GetVpcRouteTablesV1InvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetVpcRouteTablesV1Result> getVpcRouteTablesV1(GetVpcRouteTablesV1Args args, InvokeOptions options)
public static Output<GetVpcRouteTablesV1Result> getVpcRouteTablesV1(GetVpcRouteTablesV1Args args, InvokeOptions options)
public static Output<GetVpcRouteTablesV1Result> getVpcRouteTablesV1(GetVpcRouteTablesV1Args args, InvokeOutputOptions options)

fn::invoke:
  function: opentelekomcloud:index/getVpcRouteTablesV1:getVpcRouteTablesV1
  arguments:
    # arguments dictionary

data "opentelekomcloud_get_vpc_route_tables_v1" "name" {
    # arguments
}