exoscale.getNlb

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

const myNlb = exoscale.getNlb({
    zone: "ch-gva-2",
    name: "my-nlb",
});
export const myNlbId = myNlb.then(myNlb => myNlb.id);

import pulumi
import pulumi_exoscale as exoscale

my_nlb = exoscale.get_nlb(zone="ch-gva-2",
    name="my-nlb")
pulumi.export("myNlbId", my_nlb.id)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-exoscale/sdk/go/exoscale"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myNlb, err := exoscale.LookupNlb(ctx, &exoscale.LookupNlbArgs{
			Zone: "ch-gva-2",
			Name: pulumi.StringRef("my-nlb"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("myNlbId", myNlb.Id)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myNlb = Exoscale.GetNlb.Invoke(new()
    {
        Zone = "ch-gva-2",
        Name = "my-nlb",
    });

    return new Dictionary<string, object?>
    {
        ["myNlbId"] = myNlb.Apply(getNlbResult => getNlbResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.exoscale.ExoscaleFunctions;
import com.pulumi.exoscale.inputs.GetNlbArgs;
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 myNlb = ExoscaleFunctions.getNlb(GetNlbArgs.builder()
            .zone("ch-gva-2")
            .name("my-nlb")
            .build());

        ctx.export("myNlbId", myNlb.applyValue(getNlbResult -> getNlbResult.id()));
    }
}

variables:
  myNlb:
    fn::invoke:
      Function: exoscale:getNlb
      Arguments:
        zone: ch-gva-2
        name: my-nlb
outputs:
  myNlbId: ${myNlb.id}

function getNlb(args: GetNlbArgs, opts?: InvokeOptions): Promise<GetNlbResult>
function getNlbOutput(args: GetNlbOutputArgs, opts?: InvokeOptions): Output<GetNlbResult>

def get_nlb(id: Optional[str] = None,
            name: Optional[str] = None,
            zone: Optional[str] = None,
            opts: Optional[InvokeOptions] = None) -> GetNlbResult
def get_nlb_output(id: Optional[pulumi.Input[str]] = None,
            name: Optional[pulumi.Input[str]] = None,
            zone: Optional[pulumi.Input[str]] = None,
            opts: Optional[InvokeOptions] = None) -> Output[GetNlbResult]

func LookupNlb(ctx *Context, args *LookupNlbArgs, opts ...InvokeOption) (*LookupNlbResult, error)
func LookupNlbOutput(ctx *Context, args *LookupNlbOutputArgs, opts ...InvokeOption) LookupNlbResultOutput

public static class GetNlb 
{
    public static Task<GetNlbResult> InvokeAsync(GetNlbArgs args, InvokeOptions? opts = null)
    public static Output<GetNlbResult> Invoke(GetNlbInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetNlbResult> getNlb(GetNlbArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: exoscale:index/getNlb:getNlb
  arguments:
    # arguments dictionary