linode.getVpcSubnets

Linode v5.4.0 published on Friday, Oct 10, 2025 by Pulumi

pulumi/pulumi-linode

Example Usage

The following example shows how one might use this data source to list VPC subnets.

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

const filtered_subnets = linode.getVpcSubnets({
    vpcId: 123,
    filters: [{
        name: "label",
        values: ["test"],
    }],
});
export const vpcSubnets = filtered_subnets.then(filtered_subnets => filtered_subnets.vpcSubnets);

import pulumi
import pulumi_linode as linode

filtered_subnets = linode.get_vpc_subnets(vpc_id=123,
    filters=[{
        "name": "label",
        "values": ["test"],
    }])
pulumi.export("vpcSubnets", filtered_subnets.vpc_subnets)

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v5/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		filtered_subnets, err := linode.GetVpcSubnets(ctx, &linode.GetVpcSubnetsArgs{
			VpcId: 123,
			Filters: []linode.GetVpcSubnetsFilter{
				{
					Name: "label",
					Values: []string{
						"test",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("vpcSubnets", filtered_subnets.VpcSubnets)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var filtered_subnets = Linode.GetVpcSubnets.Invoke(new()
    {
        VpcId = 123,
        Filters = new[]
        {
            new Linode.Inputs.GetVpcSubnetsFilterInputArgs
            {
                Name = "label",
                Values = new[]
                {
                    "test",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["vpcSubnets"] = filtered_subnets.Apply(filtered_subnets => filtered_subnets.Apply(getVpcSubnetsResult => getVpcSubnetsResult.VpcSubnets)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetVpcSubnetsArgs;
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 filtered-subnets = LinodeFunctions.getVpcSubnets(GetVpcSubnetsArgs.builder()
            .vpcId(123)
            .filters(GetVpcSubnetsFilterArgs.builder()
                .name("label")
                .values("test")
                .build())
            .build());

        ctx.export("vpcSubnets", filtered_subnets.vpcSubnets());
    }
}

variables:
  filtered-subnets:
    fn::invoke:
      function: linode:getVpcSubnets
      arguments:
        vpcId: 123
        filters:
          - name: label
            values:
              - test
outputs:
  vpcSubnets: ${["filtered-subnets"].vpcSubnets}

IPv6

Limited Availability IPv6 VPCs may not currently be available to all users.

The following attributes are exported under each entry of the ipv6 field:

range - An IPv6 range allocated to this subnet in CIDR format.

Filterable Fields

id
label
ipv4

Using getVpcSubnets

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getVpcSubnets(args: GetVpcSubnetsArgs, opts?: InvokeOptions): Promise<GetVpcSubnetsResult>
function getVpcSubnetsOutput(args: GetVpcSubnetsOutputArgs, opts?: InvokeOptions): Output<GetVpcSubnetsResult>

def get_vpc_subnets(filters: Optional[Sequence[GetVpcSubnetsFilter]] = None,
                    vpc_id: Optional[int] = None,
                    vpc_subnets: Optional[Sequence[GetVpcSubnetsVpcSubnet]] = None,
                    opts: Optional[InvokeOptions] = None) -> GetVpcSubnetsResult
def get_vpc_subnets_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetVpcSubnetsFilterArgs]]]] = None,
                    vpc_id: Optional[pulumi.Input[int]] = None,
                    vpc_subnets: Optional[pulumi.Input[Sequence[pulumi.Input[GetVpcSubnetsVpcSubnetArgs]]]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetVpcSubnetsResult]

func GetVpcSubnets(ctx *Context, args *GetVpcSubnetsArgs, opts ...InvokeOption) (*GetVpcSubnetsResult, error)
func GetVpcSubnetsOutput(ctx *Context, args *GetVpcSubnetsOutputArgs, opts ...InvokeOption) GetVpcSubnetsResultOutput

> Note: This function is named GetVpcSubnets in the Go SDK.

public static class GetVpcSubnets 
{
    public static Task<GetVpcSubnetsResult> InvokeAsync(GetVpcSubnetsArgs args, InvokeOptions? opts = null)
    public static Output<GetVpcSubnetsResult> Invoke(GetVpcSubnetsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVpcSubnetsResult> getVpcSubnets(GetVpcSubnetsArgs args, InvokeOptions options)
public static Output<GetVpcSubnetsResult> getVpcSubnets(GetVpcSubnetsArgs args, InvokeOptions options)

fn::invoke:
  function: linode:index/getVpcSubnets:getVpcSubnets
  arguments:
    # arguments dictionary

The following arguments are supported:

VpcId int