scaleway.getLbFrontend

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

const ip01 = new scaleway.LoadbalancerIp("ip01", {});
const lb01 = new scaleway.Loadbalancer("lb01", {
    ipId: ip01.id,
    type: "lb-s",
});
const bkd01 = new scaleway.LoadbalancerBackend("bkd01", {
    lbId: lb01.id,
    forwardProtocol: "tcp",
    forwardPort: 80,
    proxyProtocol: "none",
});
const frt01 = new scaleway.LoadbalancerFrontend("frt01", {
    lbId: lb01.id,
    backendId: bkd01.id,
    inboundPort: 80,
});
const byID = scaleway.getLbFrontendOutput({
    frontendId: frt01.id,
});
const byName = scaleway.getLbFrontendOutput({
    name: frt01.name,
    lbId: lb01.id,
});

import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

ip01 = scaleway.LoadbalancerIp("ip01")
lb01 = scaleway.Loadbalancer("lb01",
    ip_id=ip01.id,
    type="lb-s")
bkd01 = scaleway.LoadbalancerBackend("bkd01",
    lb_id=lb01.id,
    forward_protocol="tcp",
    forward_port=80,
    proxy_protocol="none")
frt01 = scaleway.LoadbalancerFrontend("frt01",
    lb_id=lb01.id,
    backend_id=bkd01.id,
    inbound_port=80)
by_id = scaleway.get_lb_frontend_output(frontend_id=frt01.id)
by_name = scaleway.get_lb_frontend_output(name=frt01.name,
    lb_id=lb01.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 {
		ip01, err := scaleway.NewLoadbalancerIp(ctx, "ip01", nil)
		if err != nil {
			return err
		}
		lb01, err := scaleway.NewLoadbalancer(ctx, "lb01", &scaleway.LoadbalancerArgs{
			IpId: ip01.ID(),
			Type: pulumi.String("lb-s"),
		})
		if err != nil {
			return err
		}
		bkd01, err := scaleway.NewLoadbalancerBackend(ctx, "bkd01", &scaleway.LoadbalancerBackendArgs{
			LbId:            lb01.ID(),
			ForwardProtocol: pulumi.String("tcp"),
			ForwardPort:     pulumi.Int(80),
			ProxyProtocol:   pulumi.String("none"),
		})
		if err != nil {
			return err
		}
		frt01, err := scaleway.NewLoadbalancerFrontend(ctx, "frt01", &scaleway.LoadbalancerFrontendArgs{
			LbId:        lb01.ID(),
			BackendId:   bkd01.ID(),
			InboundPort: pulumi.Int(80),
		})
		if err != nil {
			return err
		}
		_ = scaleway.GetLbFrontendOutput(ctx, scaleway.GetLbFrontendOutputArgs{
			FrontendId: frt01.ID(),
		}, nil)
		_ = scaleway.GetLbFrontendOutput(ctx, scaleway.GetLbFrontendOutputArgs{
			Name: frt01.Name,
			LbId: lb01.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 ip01 = new Scaleway.LoadbalancerIp("ip01");

    var lb01 = new Scaleway.Loadbalancer("lb01", new()
    {
        IpId = ip01.Id,
        Type = "lb-s",
    });

    var bkd01 = new Scaleway.LoadbalancerBackend("bkd01", new()
    {
        LbId = lb01.Id,
        ForwardProtocol = "tcp",
        ForwardPort = 80,
        ProxyProtocol = "none",
    });

    var frt01 = new Scaleway.LoadbalancerFrontend("frt01", new()
    {
        LbId = lb01.Id,
        BackendId = bkd01.Id,
        InboundPort = 80,
    });

    var byID = Scaleway.GetLbFrontend.Invoke(new()
    {
        FrontendId = frt01.Id,
    });

    var byName = Scaleway.GetLbFrontend.Invoke(new()
    {
        Name = frt01.Name,
        LbId = lb01.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.LoadbalancerFrontend;
import com.pulumi.scaleway.LoadbalancerFrontendArgs;
import com.pulumi.scaleway.ScalewayFunctions;
import com.pulumi.scaleway.inputs.GetLbFrontendArgs;
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 ip01 = new LoadbalancerIp("ip01");

        var lb01 = new Loadbalancer("lb01", LoadbalancerArgs.builder()        
            .ipId(ip01.id())
            .type("lb-s")
            .build());

        var bkd01 = new LoadbalancerBackend("bkd01", LoadbalancerBackendArgs.builder()        
            .lbId(lb01.id())
            .forwardProtocol("tcp")
            .forwardPort(80)
            .proxyProtocol("none")
            .build());

        var frt01 = new LoadbalancerFrontend("frt01", LoadbalancerFrontendArgs.builder()        
            .lbId(lb01.id())
            .backendId(bkd01.id())
            .inboundPort(80)
            .build());

        final var byID = ScalewayFunctions.getLbFrontend(GetLbFrontendArgs.builder()
            .frontendId(frt01.id())
            .build());

        final var byName = ScalewayFunctions.getLbFrontend(GetLbFrontendArgs.builder()
            .name(frt01.name())
            .lbId(lb01.id())
            .build());

    }
}

resources:
  ip01:
    type: scaleway:LoadbalancerIp
  lb01:
    type: scaleway:Loadbalancer
    properties:
      ipId: ${ip01.id}
      type: lb-s
  bkd01:
    type: scaleway:LoadbalancerBackend
    properties:
      lbId: ${lb01.id}
      forwardProtocol: tcp
      forwardPort: 80
      proxyProtocol: none
  frt01:
    type: scaleway:LoadbalancerFrontend
    properties:
      lbId: ${lb01.id}
      backendId: ${bkd01.id}
      inboundPort: 80
variables:
  byID:
    fn::invoke:
      Function: scaleway:getLbFrontend
      Arguments:
        frontendId: ${frt01.id}
  byName:
    fn::invoke:
      Function: scaleway:getLbFrontend
      Arguments:
        name: ${frt01.name}
        lbId: ${lb01.id}

function getLbFrontend(args: GetLbFrontendArgs, opts?: InvokeOptions): Promise<GetLbFrontendResult>
function getLbFrontendOutput(args: GetLbFrontendOutputArgs, opts?: InvokeOptions): Output<GetLbFrontendResult>

def get_lb_frontend(frontend_id: Optional[str] = None,
                    lb_id: Optional[str] = None,
                    name: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetLbFrontendResult
def get_lb_frontend_output(frontend_id: Optional[pulumi.Input[str]] = None,
                    lb_id: Optional[pulumi.Input[str]] = None,
                    name: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetLbFrontendResult]

func GetLbFrontend(ctx *Context, args *GetLbFrontendArgs, opts ...InvokeOption) (*GetLbFrontendResult, error)
func GetLbFrontendOutput(ctx *Context, args *GetLbFrontendOutputArgs, opts ...InvokeOption) GetLbFrontendResultOutput

public static class GetLbFrontend 
{
    public static Task<GetLbFrontendResult> InvokeAsync(GetLbFrontendArgs args, InvokeOptions? opts = null)
    public static Output<GetLbFrontendResult> Invoke(GetLbFrontendInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetLbFrontendResult> getLbFrontend(GetLbFrontendArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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