getSubnets function

Future<GetSubnetsResult> getSubnets(
  1. GetSubnetsArgs args, {
  2. InvokeOptions? options,
})

This resource can be useful for getting back a set of subnet IDs.

Example Usage

The following shows outputting all CIDR blocks for every subnet ID in a VPC.

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

const example = aws.ec2.getSubnets({
    filters: [{
        name: "vpc-id",
        values: [vpcId],
    }],
});
const exampleGetSubnet = example.then(example => std.toset({
    input: example.ids,
})).then(invoke => .reduce((__obj, [__key, __value]) => ({ ...__obj, [String(__key)]: aws.ec2.getSubnet({
    id: __value,
}) }), {}));
export const subnetCidrBlocks = exampleGetSubnet.apply(exampleGetSubnet => Object.values(exampleGetSubnet).map(s => (s.cidrBlock)));
import pulumi
import pulumi_aws as aws
import pulumi_std as std

example = aws.ec2.get_subnets(filters=[{
    "name": "vpc-id",
    "values": [vpc_id],
}])
example_get_subnet = {str(__key): aws.ec2.get_subnet(id=__value) for __key, __value in enumerate(std.toset(input=example.ids).result)}
pulumi.export("subnetCidrBlocks", [s.cidr_block for s in example_get_subnet.values()])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Ec2.GetSubnets.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetSubnetsFilterInputArgs
            {
                Name = "vpc-id",
                Values = new[]
                {
                    vpcId,
                },
            },
        },
    });

    var exampleGetSubnet = Std.Toset.Invoke(new()
    {
        Input = example.Apply(getSubnetsResult => getSubnetsResult.Ids),
    }).Apply(invoke => );

    return new Dictionary<string, object?>
    {
        ["subnetCidrBlocks"] = exampleGetSubnet.Apply(exampleGetSubnet => (exampleGetSubnet).Values.Select(s =>
        {
            return s.CidrBlock;
        }).ToList()),
    };
});
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

data "aws_ec2_getsubnets" "example" {
  filters {
    name   = "vpc-id"
    values = [vpcId]
  }
}
data "aws_ec2_getsubnet" "invoke_1" {
  for_each = toset(data.aws_ec2_getsubnets.example.ids)
  id       = each.value
}

locals {
  exampleGetSubnet = {for __key, __value in toset(data.aws_ec2_getsubnets.example.ids) : __key => data.aws_ec2_getsubnet.invoke_1[__key]}
}
output "subnetCidrBlocks" {
  value = [for s in local.exampleGetSubnet : s.cidrBlock]
}

The following example retrieves a set of all subnets in a VPC with a custom tag of Tier set to a value of "Private" so that the aws.ec2.Instance resource can loop through the subnets, putting instances across availability zones.

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

export = async () => {
    const _private = await aws.ec2.getSubnets({
        filters: [{
            name: "vpc-id",
            values: [vpcId],
        }],
        tags: {
            Tier: "Private",
        },
    });
    const app: aws.ec2.Instance[] = [];
    for (const range of std.toset({
        input: _private.ids,
    }).result.map((v, k) => ({key: k, value: v}))) {
        app.push(new aws.ec2.Instance(`app-${range.key}`, {
            ami: ami,
            instanceType: aws.ec2.InstanceType.T2_Micro,
            subnetId: range.value,
        }));
    }
}
import pulumi
from typing import Any
import pulumi_aws as aws
import pulumi_std as std

private = aws.ec2.get_subnets(filters=[{
        "name": "vpc-id",
        "values": [vpc_id],
    }],
    tags={
        "Tier": "Private",
    })
app: list[aws.ec2.Instance] = []
for app_range in [{"key": k, "value": v} for [k, v] in enumerate(std.toset(input=private.ids).result)]:
    app.append(aws.ec2.Instance(f"app-{app_range['key']}",
        ami=ami,
        instance_type=aws.ec2.InstanceType.T2_MICRO,
        subnet_id=app_range["value"]))
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;

return await Deployment.RunAsync(async() =>
{
    var @private = await Aws.Ec2.GetSubnets.InvokeAsync(new()
    {
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetSubnetsFilterArgs
            {
                Name = "vpc-id",
                Values = new[]
                {
                    vpcId,
                },
            },
        },
        Tags =
        {
            { "Tier", "Private" },
        },
    });

    var app = new List<Aws.Ec2.Instance>();
    foreach (var range in )
    {
        app.Add(new Aws.Ec2.Instance($"app-{range.Key}", new()
        {
            Ami = ami,
            InstanceType = Aws.Ec2.InstanceType.T2_Micro,
            SubnetId = range.Value,
        }));
    }
});
package main

import (
	"fmt"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		private, err := ec2.GetSubnets(ctx, &ec2.GetSubnetsArgs{
			Filters: []ec2.GetSubnetsFilter{
				{
					Name: "vpc-id",
					Values: pulumi.StringArray{
						vpcId,
					},
				},
			},
			Tags: map[string]string{
				"Tier": "Private",
			},
		}, nil)
		if err != nil {
			return err
		}
		var app []*ec2.Instance
		for key0, val0 := range []interface{}(std.Toset(ctx, &std.TosetArgs{
			Input: private.Ids,
		}, nil).Result) {
			__res, err := ec2.NewInstance(ctx, fmt.Sprintf("app-%v", key0), &ec2.InstanceArgs{
				Ami:          pulumi.Any(ami),
				InstanceType: pulumi.String(ec2.InstanceType_T2_Micro),
				SubnetId:     pulumi.Any(val0),
			})
			if err != nil {
				return err
			}
			app = append(app, __res)
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

data "aws_ec2_getsubnets" "private" {
  filters {
    name   = "vpc-id"
    values = [vpcId]
  }
  tags = {
    "Tier" = "Private"
  }
}

resource "aws_ec2_instance" "app" {
  for_each      = toset(data.aws_ec2_getsubnets.private.ids)
  ami           = ami
  instance_type = "t2.micro"
  subnet_id     = each.value
}
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.GetSubnetsArgs;
import com.pulumi.aws.ec2.inputs.GetSubnetsFilterArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
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 private = Ec2Functions.getSubnets(GetSubnetsArgs.builder()
            .filters(GetSubnetsFilterArgs.builder()
                .name("vpc-id")
                .values(vpcId)
                .build())
            .tags(Map.of("Tier", "Private"))
            .build());

        for (var range : KeyedValue.of(com.pulumi.std.StdFunctions(com.pulumi.std.inputs.TosetArgs.builder()
            .input(private_.ids())
            .build()).result())) {
            new Instance("app-" + range.key(), InstanceArgs.builder()
                .ami(ami)
                .instanceType("t2.micro")
                .subnetId(range.value())
                .build());
        }

    }
}
resources:
  app:
    type: aws:ec2:Instance
    properties:
      ami: ${ami}
      instanceType: t2.micro
      subnetId: ${range.value}
    options: {}
variables:
  private:
    fn::invoke:
      function: aws:ec2:getSubnets
      arguments:
        filters:
          - name: vpc-id
            values:
              - ${vpcId}
        tags:
          Tier: Private

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

Implementation

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