proxmoxve.SDNZone.getVxlan

import * as pulumi from "@pulumi/pulumi";
import * as proxmoxve from "@muhlba91/pulumi-proxmoxve";

const example = proxmoxve.SDNZone.getVxlan({
    id: "vxlan1",
});
export const dataProxmoxVirtualEnvironmentSdnZoneVxlan = {
    id: example.then(example => example.id),
    nodes: example.then(example => example.nodes),
    peers: example.then(example => example.peers),
    mtu: example.then(example => example.mtu),
    dns: example.then(example => example.dns),
    dns_zone: example.then(example => example.dnsZone),
    ipam: example.then(example => example.ipam),
    reverse_dns: example.then(example => example.reverseDns),
};

import pulumi
import pulumi_proxmoxve as proxmoxve

example = proxmoxve.SDNZone.get_vxlan(id="vxlan1")
pulumi.export("dataProxmoxVirtualEnvironmentSdnZoneVxlan", {
    "id": example.id,
    "nodes": example.nodes,
    "peers": example.peers,
    "mtu": example.mtu,
    "dns": example.dns,
    "dns_zone": example.dns_zone,
    "ipam": example.ipam,
    "reverse_dns": example.reverse_dns,
})

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v7/go/proxmoxve/sdnzone"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sdnzone.GetVxlan(ctx, &sdnzone.GetVxlanArgs{
			Id: "vxlan1",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentSdnZoneVxlan", pulumi.Map{
			"id":          example.Id,
			"nodes":       example.Nodes,
			"peers":       example.Peers,
			"mtu":         example.Mtu,
			"dns":         example.Dns,
			"dns_zone":    example.DnsZone,
			"ipam":        example.Ipam,
			"reverse_dns": example.ReverseDns,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ProxmoxVE.SDNZone.GetVxlan.Invoke(new()
    {
        Id = "vxlan1",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentSdnZoneVxlan"] = 
        {
            { "id", example.Apply(getVxlanResult => getVxlanResult.Id) },
            { "nodes", example.Apply(getVxlanResult => getVxlanResult.Nodes) },
            { "peers", example.Apply(getVxlanResult => getVxlanResult.Peers) },
            { "mtu", example.Apply(getVxlanResult => getVxlanResult.Mtu) },
            { "dns", example.Apply(getVxlanResult => getVxlanResult.Dns) },
            { "dns_zone", example.Apply(getVxlanResult => getVxlanResult.DnsZone) },
            { "ipam", example.Apply(getVxlanResult => getVxlanResult.Ipam) },
            { "reverse_dns", example.Apply(getVxlanResult => getVxlanResult.ReverseDns) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.SDNZone.SDNZoneFunctions;
import com.pulumi.proxmoxve.SDNZone.inputs.GetVxlanArgs;
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 example = SDNZoneFunctions.getVxlan(GetVxlanArgs.builder()
            .id("vxlan1")
            .build());

        ctx.export("dataProxmoxVirtualEnvironmentSdnZoneVxlan", Map.ofEntries(
            Map.entry("id", example.id()),
            Map.entry("nodes", example.nodes()),
            Map.entry("peers", example.peers()),
            Map.entry("mtu", example.mtu()),
            Map.entry("dns", example.dns()),
            Map.entry("dns_zone", example.dnsZone()),
            Map.entry("ipam", example.ipam()),
            Map.entry("reverse_dns", example.reverseDns())
        ));
    }
}

variables:
  example:
    fn::invoke:
      function: proxmoxve:SDNZone:getVxlan
      arguments:
        id: vxlan1
outputs:
  dataProxmoxVirtualEnvironmentSdnZoneVxlan:
    id: ${example.id}
    nodes: ${example.nodes}
    peers: ${example.peers}
    mtu: ${example.mtu}
    dns: ${example.dns}
    dns_zone: ${example.dnsZone}
    ipam: ${example.ipam}
    reverse_dns: ${example.reverseDns}

function getVxlan(args: GetVxlanArgs, opts?: InvokeOptions): Promise<GetVxlanResult>
function getVxlanOutput(args: GetVxlanOutputArgs, opts?: InvokeOptions): Output<GetVxlanResult>

def get_vxlan(id: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> GetVxlanResult
def get_vxlan_output(id: Optional[pulumi.Input[str]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetVxlanResult]

func LookupVxlan(ctx *Context, args *LookupVxlanArgs, opts ...InvokeOption) (*LookupVxlanResult, error)
func LookupVxlanOutput(ctx *Context, args *LookupVxlanOutputArgs, opts ...InvokeOption) LookupVxlanResultOutput

public static class GetVxlan 
{
    public static Task<GetVxlanResult> InvokeAsync(GetVxlanArgs args, InvokeOptions? opts = null)
    public static Output<GetVxlanResult> Invoke(GetVxlanInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVxlanResult> getVxlan(GetVxlanArgs args, InvokeOptions options)
public static Output<GetVxlanResult> getVxlan(GetVxlanArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:SDNZone/getVxlan:getVxlan
  arguments:
    # arguments dictionary