netbox.getVlan

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

const vlan1 = netbox.getVlan({
    name: "vlan-1",
});
const vlan2 = netbox.getVlan({
    vid: 1234,
    role: netbox_ipam_role.example.id,
});
const vlan3 = netbox.getVlan({
    name: "vlan-3",
    tenant: netbox_tenant.example.id,
});

import pulumi
import pulumi_netbox as netbox

vlan1 = netbox.get_vlan(name="vlan-1")
vlan2 = netbox.get_vlan(vid=1234,
    role=netbox_ipam_role["example"]["id"])
vlan3 = netbox.get_vlan(name="vlan-3",
    tenant=netbox_tenant["example"]["id"])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netbox/v3/netbox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := netbox.LookupVlan(ctx, &netbox.LookupVlanArgs{
			Name: pulumi.StringRef("vlan-1"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = netbox.LookupVlan(ctx, &netbox.LookupVlanArgs{
			Vid:  pulumi.Float64Ref(1234),
			Role: pulumi.Float64Ref(netbox_ipam_role.Example.Id),
		}, nil)
		if err != nil {
			return err
		}
		_, err = netbox.LookupVlan(ctx, &netbox.LookupVlanArgs{
			Name:   pulumi.StringRef("vlan-3"),
			Tenant: pulumi.Float64Ref(netbox_tenant.Example.Id),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var vlan1 = Netbox.GetVlan.Invoke(new()
    {
        Name = "vlan-1",
    });

    var vlan2 = Netbox.GetVlan.Invoke(new()
    {
        Vid = 1234,
        Role = netbox_ipam_role.Example.Id,
    });

    var vlan3 = Netbox.GetVlan.Invoke(new()
    {
        Name = "vlan-3",
        Tenant = netbox_tenant.Example.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.netbox.NetboxFunctions;
import com.pulumi.netbox.inputs.GetVlanArgs;
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 vlan1 = NetboxFunctions.getVlan(GetVlanArgs.builder()
            .name("vlan-1")
            .build());

        final var vlan2 = NetboxFunctions.getVlan(GetVlanArgs.builder()
            .vid(1234)
            .role(netbox_ipam_role.example().id())
            .build());

        final var vlan3 = NetboxFunctions.getVlan(GetVlanArgs.builder()
            .name("vlan-3")
            .tenant(netbox_tenant.example().id())
            .build());

    }
}

variables:
  vlan1:
    fn::invoke:
      function: netbox:getVlan
      arguments:
        name: vlan-1
  vlan2:
    fn::invoke:
      function: netbox:getVlan
      arguments:
        vid: 1234
        role: ${netbox_ipam_role.example.id}
  vlan3:
    fn::invoke:
      function: netbox:getVlan
      arguments:
        name: vlan-3
        tenant: ${netbox_tenant.example.id}

function getVlan(args: GetVlanArgs, opts?: InvokeOptions): Promise<GetVlanResult>
function getVlanOutput(args: GetVlanOutputArgs, opts?: InvokeOptions): Output<GetVlanResult>

def get_vlan(group_id: Optional[float] = None,
             id: Optional[str] = None,
             name: Optional[str] = None,
             role: Optional[float] = None,
             tenant: Optional[float] = None,
             vid: Optional[float] = None,
             opts: Optional[InvokeOptions] = None) -> GetVlanResult
def get_vlan_output(group_id: Optional[pulumi.Input[float]] = None,
             id: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
             role: Optional[pulumi.Input[float]] = None,
             tenant: Optional[pulumi.Input[float]] = None,
             vid: Optional[pulumi.Input[float]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetVlanResult]

func LookupVlan(ctx *Context, args *LookupVlanArgs, opts ...InvokeOption) (*LookupVlanResult, error)
func LookupVlanOutput(ctx *Context, args *LookupVlanOutputArgs, opts ...InvokeOption) LookupVlanResultOutput

public static class GetVlan 
{
    public static Task<GetVlanResult> InvokeAsync(GetVlanArgs args, InvokeOptions? opts = null)
    public static Output<GetVlanResult> Invoke(GetVlanInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVlanResult> getVlan(GetVlanArgs args, InvokeOptions options)
public static Output<GetVlanResult> getVlan(GetVlanArgs args, InvokeOptions options)

fn::invoke:
  function: netbox:index/getVlan:getVlan
  arguments:
    # arguments dictionary