scaleway.getLbBackend

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumi/scaleway";
import * as scaleway from "@pulumiverse/scaleway";

const mainLoadbalancerIp = new scaleway.LoadbalancerIp("mainLoadbalancerIp", {});
const mainLoadbalancer = new scaleway.Loadbalancer("mainLoadbalancer", {
    ipId: mainLoadbalancerIp.id,
    type: "LB-S",
});
const mainLoadbalancerBackend = new scaleway.LoadbalancerBackend("mainLoadbalancerBackend", {
    lbId: mainLoadbalancer.id,
    forwardProtocol: "http",
    forwardPort: 80,
});
const byID = scaleway.getLbBackendOutput({
    backendId: mainLoadbalancerBackend.id,
});
const byName = scaleway.getLbBackendOutput({
    name: mainLoadbalancerBackend.name,
    lbId: mainLoadbalancer.id,
});

import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

main_loadbalancer_ip = scaleway.LoadbalancerIp("mainLoadbalancerIp")
main_loadbalancer = scaleway.Loadbalancer("mainLoadbalancer",
    ip_id=main_loadbalancer_ip.id,
    type="LB-S")
main_loadbalancer_backend = scaleway.LoadbalancerBackend("mainLoadbalancerBackend",
    lb_id=main_loadbalancer.id,
    forward_protocol="http",
    forward_port=80)
by_id = scaleway.get_lb_backend_output(backend_id=main_loadbalancer_backend.id)
by_name = scaleway.get_lb_backend_output(name=main_loadbalancer_backend.name,
    lb_id=main_loadbalancer.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		mainLoadbalancerIp, err := scaleway.NewLoadbalancerIp(ctx, "mainLoadbalancerIp", nil)
		if err != nil {
			return err
		}
		mainLoadbalancer, err := scaleway.NewLoadbalancer(ctx, "mainLoadbalancer", &scaleway.LoadbalancerArgs{
			IpId: mainLoadbalancerIp.ID(),
			Type: pulumi.String("LB-S"),
		})
		if err != nil {
			return err
		}
		mainLoadbalancerBackend, err := scaleway.NewLoadbalancerBackend(ctx, "mainLoadbalancerBackend", &scaleway.LoadbalancerBackendArgs{
			LbId:            mainLoadbalancer.ID(),
			ForwardProtocol: pulumi.String("http"),
			ForwardPort:     pulumi.Int(80),
		})
		if err != nil {
			return err
		}
		_ = scaleway.GetLbBackendOutput(ctx, scaleway.GetLbBackendOutputArgs{
			BackendId: mainLoadbalancerBackend.ID(),
		}, nil)
		_ = scaleway.GetLbBackendOutput(ctx, scaleway.GetLbBackendOutputArgs{
			Name: mainLoadbalancerBackend.Name,
			LbId: mainLoadbalancer.ID(),
		}, nil)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumi.Scaleway;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var mainLoadbalancerIp = new Scaleway.LoadbalancerIp("mainLoadbalancerIp");

    var mainLoadbalancer = new Scaleway.Loadbalancer("mainLoadbalancer", new()
    {
        IpId = mainLoadbalancerIp.Id,
        Type = "LB-S",
    });

    var mainLoadbalancerBackend = new Scaleway.LoadbalancerBackend("mainLoadbalancerBackend", new()
    {
        LbId = mainLoadbalancer.Id,
        ForwardProtocol = "http",
        ForwardPort = 80,
    });

    var byID = Scaleway.GetLbBackend.Invoke(new()
    {
        BackendId = mainLoadbalancerBackend.Id,
    });

    var byName = Scaleway.GetLbBackend.Invoke(new()
    {
        Name = mainLoadbalancerBackend.Name,
        LbId = mainLoadbalancer.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.LoadbalancerIp;
import com.pulumi.scaleway.Loadbalancer;
import com.pulumi.scaleway.LoadbalancerArgs;
import com.pulumi.scaleway.LoadbalancerBackend;
import com.pulumi.scaleway.LoadbalancerBackendArgs;
import com.pulumi.scaleway.ScalewayFunctions;
import com.pulumi.scaleway.inputs.GetLbBackendArgs;
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) {
        var mainLoadbalancerIp = new LoadbalancerIp("mainLoadbalancerIp");

        var mainLoadbalancer = new Loadbalancer("mainLoadbalancer", LoadbalancerArgs.builder()        
            .ipId(mainLoadbalancerIp.id())
            .type("LB-S")
            .build());

        var mainLoadbalancerBackend = new LoadbalancerBackend("mainLoadbalancerBackend", LoadbalancerBackendArgs.builder()        
            .lbId(mainLoadbalancer.id())
            .forwardProtocol("http")
            .forwardPort("80")
            .build());

        final var byID = ScalewayFunctions.getLbBackend(GetLbBackendArgs.builder()
            .backendId(mainLoadbalancerBackend.id())
            .build());

        final var byName = ScalewayFunctions.getLbBackend(GetLbBackendArgs.builder()
            .name(mainLoadbalancerBackend.name())
            .lbId(mainLoadbalancer.id())
            .build());

    }
}

resources:
  mainLoadbalancerIp:
    type: scaleway:LoadbalancerIp
  mainLoadbalancer:
    type: scaleway:Loadbalancer
    properties:
      ipId: ${mainLoadbalancerIp.id}
      type: LB-S
  mainLoadbalancerBackend:
    type: scaleway:LoadbalancerBackend
    properties:
      lbId: ${mainLoadbalancer.id}
      forwardProtocol: http
      forwardPort: '80'
variables:
  byID:
    fn::invoke:
      Function: scaleway:getLbBackend
      Arguments:
        backendId: ${mainLoadbalancerBackend.id}
  byName:
    fn::invoke:
      Function: scaleway:getLbBackend
      Arguments:
        name: ${mainLoadbalancerBackend.name}
        lbId: ${mainLoadbalancer.id}

function getLbBackend(args: GetLbBackendArgs, opts?: InvokeOptions): Promise<GetLbBackendResult>
function getLbBackendOutput(args: GetLbBackendOutputArgs, opts?: InvokeOptions): Output<GetLbBackendResult>

def get_lb_backend(backend_id: Optional[str] = None,
                   lb_id: Optional[str] = None,
                   name: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetLbBackendResult
def get_lb_backend_output(backend_id: Optional[pulumi.Input[str]] = None,
                   lb_id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetLbBackendResult]

func GetLbBackend(ctx *Context, args *GetLbBackendArgs, opts ...InvokeOption) (*GetLbBackendResult, error)
func GetLbBackendOutput(ctx *Context, args *GetLbBackendOutputArgs, opts ...InvokeOption) GetLbBackendResultOutput

public static class GetLbBackend 
{
    public static Task<GetLbBackendResult> InvokeAsync(GetLbBackendArgs args, InvokeOptions? opts = null)
    public static Output<GetLbBackendResult> Invoke(GetLbBackendInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetLbBackendResult> getLbBackend(GetLbBackendArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: scaleway:index/getLbBackend:getLbBackend
  arguments:
    # arguments dictionary