proxmoxve.sdn/controller.getEvpn

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

const example = proxmoxve.sdn.controller.getEvpn({
    id: "evpn1",
});
export const dataProxmoxSdnControllerEvpn = {
    id: example.then(example => example.id),
    asn: example.then(example => example.asn),
    fabric: example.then(example => example.fabric),
    peers: example.then(example => example.peers),
};

import pulumi
import pulumi_proxmoxve as proxmoxve

example = proxmoxve.sdn.controller.get_evpn(id="evpn1")
pulumi.export("dataProxmoxSdnControllerEvpn", {
    "id": example.id,
    "asn": example.asn,
    "fabric": example.fabric,
    "peers": example.peers,
})

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v8/go/proxmoxve/sdn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sdn.GetEvpn(ctx, &controller.GetEvpnArgs{
			Id: "evpn1",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxSdnControllerEvpn", pulumi.Map{
			"id":     example.Id,
			"asn":    example.Asn,
			"fabric": example.Fabric,
			"peers":  example.Peers,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ProxmoxVE.Sdn.Controller.GetEvpn.Invoke(new()
    {
        Id = "evpn1",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxSdnControllerEvpn"] = 
        {
            { "id", example.Apply(getEvpnResult => getEvpnResult.Id) },
            { "asn", example.Apply(getEvpnResult => getEvpnResult.Asn) },
            { "fabric", example.Apply(getEvpnResult => getEvpnResult.Fabric) },
            { "peers", example.Apply(getEvpnResult => getEvpnResult.Peers) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.sdn_controller.Sdn_controllerFunctions;
import com.pulumi.proxmoxve.sdn.inputs.GetEvpnArgs;
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 example = Sdn_controllerFunctions.getEvpn(GetEvpnArgs.builder()
            .id("evpn1")
            .build());

        ctx.export("dataProxmoxSdnControllerEvpn", Map.ofEntries(
            Map.entry("id", example.id()),
            Map.entry("asn", example.asn()),
            Map.entry("fabric", example.fabric()),
            Map.entry("peers", example.peers())
        ));
    }
}

variables:
  example:
    fn::invoke:
      function: proxmoxve:sdn/controller:getEvpn
      arguments:
        id: evpn1
outputs:
  dataProxmoxSdnControllerEvpn:
    id: ${example.id}
    asn: ${example.asn}
    fabric: ${example.fabric}
    peers: ${example.peers}

function getEvpn(args: GetEvpnArgs, opts?: InvokeOptions): Promise<GetEvpnResult>
function getEvpnOutput(args: GetEvpnOutputArgs, opts?: InvokeOptions): Output<GetEvpnResult>

def get_evpn(id: Optional[str] = None,
             opts: Optional[InvokeOptions] = None) -> GetEvpnResult
def get_evpn_output(id: pulumi.Input[Optional[str]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetEvpnResult]

func LookupEvpn(ctx *Context, args *LookupEvpnArgs, opts ...InvokeOption) (*LookupEvpnResult, error)
func LookupEvpnOutput(ctx *Context, args *LookupEvpnOutputArgs, opts ...InvokeOption) LookupEvpnResultOutput

public static class GetEvpn 
{
    public static Task<GetEvpnResult> InvokeAsync(GetEvpnArgs args, InvokeOptions? opts = null)
    public static Output<GetEvpnResult> Invoke(GetEvpnInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetEvpnResult> getEvpn(GetEvpnArgs args, InvokeOptions options)
public static Output<GetEvpnResult> getEvpn(GetEvpnArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:sdn/controller/getEvpn:getEvpn
  arguments:
    # arguments dictionary

data "proxmoxve_sdn_controller_getevpn" "name" {
    # arguments
}