scaleway.loadbalancers.getFrontend

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

const ip01 = new scaleway.loadbalancers.Ip("ip01", {});
const lb01 = new scaleway.loadbalancers.LoadBalancer("lb01", {
    ipId: ip01.id,
    name: "test-lb",
    type: "lb-s",
});
const bkd01 = new scaleway.loadbalancers.Backend("bkd01", {
    lbId: lb01.id,
    forwardProtocol: "tcp",
    forwardPort: 80,
    proxyProtocol: "none",
});
const frt01 = new scaleway.loadbalancers.Frontend("frt01", {
    lbId: lb01.id,
    backendId: bkd01.id,
    inboundPort: 80,
});
const byID = scaleway.loadbalancers.getFrontendOutput({
    frontendId: frt01.id,
});
const byName = scaleway.loadbalancers.getFrontendOutput({
    name: frt01.name,
    lbId: lb01.id,
});

import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

ip01 = scaleway.loadbalancers.Ip("ip01")
lb01 = scaleway.loadbalancers.LoadBalancer("lb01",
    ip_id=ip01.id,
    name="test-lb",
    type="lb-s")
bkd01 = scaleway.loadbalancers.Backend("bkd01",
    lb_id=lb01.id,
    forward_protocol="tcp",
    forward_port=80,
    proxy_protocol="none")
frt01 = scaleway.loadbalancers.Frontend("frt01",
    lb_id=lb01.id,
    backend_id=bkd01.id,
    inbound_port=80)
by_id = scaleway.loadbalancers.get_frontend_output(frontend_id=frt01.id)
by_name = scaleway.loadbalancers.get_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/loadbalancers"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ip01, err := loadbalancers.NewIp(ctx, "ip01", nil)
		if err != nil {
			return err
		}
		lb01, err := loadbalancers.NewLoadBalancer(ctx, "lb01", &loadbalancers.LoadBalancerArgs{
			IpId: ip01.ID(),
			Name: pulumi.String("test-lb"),
			Type: pulumi.String("lb-s"),
		})
		if err != nil {
			return err
		}
		bkd01, err := loadbalancers.NewBackend(ctx, "bkd01", &loadbalancers.BackendArgs{
			LbId:            lb01.ID(),
			ForwardProtocol: pulumi.String("tcp"),
			ForwardPort:     pulumi.Int(80),
			ProxyProtocol:   pulumi.String("none"),
		})
		if err != nil {
			return err
		}
		frt01, err := loadbalancers.NewFrontend(ctx, "frt01", &loadbalancers.FrontendArgs{
			LbId:        lb01.ID(),
			BackendId:   bkd01.ID(),
			InboundPort: pulumi.Int(80),
		})
		if err != nil {
			return err
		}
		_ = loadbalancers.LookupFrontendOutput(ctx, loadbalancers.GetFrontendOutputArgs{
			FrontendId: frt01.ID(),
		}, nil)
		_ = loadbalancers.LookupFrontendOutput(ctx, loadbalancers.GetFrontendOutputArgs{
			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.Loadbalancers.Ip("ip01");

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

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

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

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

    var byName = Scaleway.Loadbalancers.GetFrontend.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.loadbalancers.Ip;
import com.pulumi.scaleway.loadbalancers.LoadBalancer;
import com.pulumi.scaleway.loadbalancers.LoadBalancerArgs;
import com.pulumi.scaleway.loadbalancers.Backend;
import com.pulumi.scaleway.loadbalancers.BackendArgs;
import com.pulumi.scaleway.loadbalancers.Frontend;
import com.pulumi.scaleway.loadbalancers.FrontendArgs;
import com.pulumi.scaleway.loadbalancers.LoadbalancersFunctions;
import com.pulumi.scaleway.loadbalancers.inputs.GetFrontendArgs;
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 Ip("ip01");

        var lb01 = new LoadBalancer("lb01", LoadBalancerArgs.builder()
            .ipId(ip01.id())
            .name("test-lb")
            .type("lb-s")
            .build());

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

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

        final var byID = LoadbalancersFunctions.getFrontend(GetFrontendArgs.builder()
            .frontendId(frt01.id())
            .build());

        final var byName = LoadbalancersFunctions.getFrontend(GetFrontendArgs.builder()
            .name(frt01.name())
            .lbId(lb01.id())
            .build());

    }
}

resources:
  ip01:
    type: scaleway:loadbalancers:Ip
  lb01:
    type: scaleway:loadbalancers:LoadBalancer
    properties:
      ipId: ${ip01.id}
      name: test-lb
      type: lb-s
  bkd01:
    type: scaleway:loadbalancers:Backend
    properties:
      lbId: ${lb01.id}
      forwardProtocol: tcp
      forwardPort: 80
      proxyProtocol: none
  frt01:
    type: scaleway:loadbalancers:Frontend
    properties:
      lbId: ${lb01.id}
      backendId: ${bkd01.id}
      inboundPort: 80
variables:
  byID:
    fn::invoke:
      function: scaleway:loadbalancers:getFrontend
      arguments:
        frontendId: ${frt01.id}
  byName:
    fn::invoke:
      function: scaleway:loadbalancers:getFrontend
      arguments:
        name: ${frt01.name}
        lbId: ${lb01.id}

function getFrontend(args: GetFrontendArgs, opts?: InvokeOptions): Promise<GetFrontendResult>
function getFrontendOutput(args: GetFrontendOutputArgs, opts?: InvokeOptions): Output<GetFrontendResult>

def get_frontend(frontend_id: Optional[str] = None,
                 lb_id: Optional[str] = None,
                 name: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetFrontendResult
def get_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[GetFrontendResult]

func LookupFrontend(ctx *Context, args *LookupFrontendArgs, opts ...InvokeOption) (*LookupFrontendResult, error)
func LookupFrontendOutput(ctx *Context, args *LookupFrontendOutputArgs, opts ...InvokeOption) LookupFrontendResultOutput

public static class GetFrontend 
{
    public static Task<GetFrontendResult> InvokeAsync(GetFrontendArgs args, InvokeOptions? opts = null)
    public static Output<GetFrontendResult> Invoke(GetFrontendInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetFrontendResult> getFrontend(GetFrontendArgs args, InvokeOptions options)
public static Output<GetFrontendResult> getFrontend(GetFrontendArgs args, InvokeOptions options)

fn::invoke:
  function: scaleway:loadbalancers/getFrontend:getFrontend
  arguments:
    # arguments dictionary