ovh.IpLoadBalancing.Refresh

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Ovh = Lbrlabs.PulumiPackage.Ovh;
using Ovh = Pulumi.Ovh;

return await Deployment.RunAsync(() => 
{
    var lb = Ovh.IpLoadBalancing.GetIpLoadBalancing.Invoke(new()
    {
        ServiceName = "ip-1.2.3.4",
        State = "ok",
    });

    var farmname = new Ovh.IpLoadBalancing.TcpFarm("farmname", new()
    {
        Port = 8080,
        ServiceName = lb.Apply(getIpLoadBalancingResult => getIpLoadBalancingResult.Id),
        Zone = "all",
    });

    var backend = new Ovh.IpLoadBalancing.TcpFarmServer("backend", new()
    {
        Address = "4.5.6.7",
        Backup = true,
        DisplayName = "mybackend",
        FarmId = farmname.Id,
        Port = 80,
        Probe = true,
        ProxyProtocolVersion = "v2",
        ServiceName = lb.Apply(getIpLoadBalancingResult => getIpLoadBalancingResult.Id),
        Ssl = false,
        Status = "active",
        Weight = 2,
    });

    var mylb = new Ovh.IpLoadBalancing.Refresh("mylb", new()
    {
        Keepers = new[]
        {
            new[]
            {
                backend,
            }.Select(__item => __item.Address).ToList(),
        },
        ServiceName = lb.Apply(getIpLoadBalancingResult => getIpLoadBalancingResult.Id),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ovh.IpLoadBalancing.IpLoadBalancingFunctions;
import com.pulumi.ovh.IpLoadBalancing.inputs.GetIpLoadBalancingArgs;
import com.pulumi.ovh.IpLoadBalancing.TcpFarm;
import com.pulumi.ovh.IpLoadBalancing.TcpFarmArgs;
import com.pulumi.ovh.IpLoadBalancing.TcpFarmServer;
import com.pulumi.ovh.IpLoadBalancing.TcpFarmServerArgs;
import com.pulumi.ovh.IpLoadBalancing.Refresh;
import com.pulumi.ovh.IpLoadBalancing.RefreshArgs;
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 lb = IpLoadBalancingFunctions.getIpLoadBalancing(GetIpLoadBalancingArgs.builder()
            .serviceName("ip-1.2.3.4")
            .state("ok")
            .build());

        var farmname = new TcpFarm("farmname", TcpFarmArgs.builder()        
            .port(8080)
            .serviceName(lb.applyValue(getIpLoadBalancingResult -> getIpLoadBalancingResult.id()))
            .zone("all")
            .build());

        var backend = new TcpFarmServer("backend", TcpFarmServerArgs.builder()        
            .address("4.5.6.7")
            .backup(true)
            .displayName("mybackend")
            .farmId(farmname.id())
            .port(80)
            .probe(true)
            .proxyProtocolVersion("v2")
            .serviceName(lb.applyValue(getIpLoadBalancingResult -> getIpLoadBalancingResult.id()))
            .ssl(false)
            .status("active")
            .weight(2)
            .build());

        var mylb = new Refresh("mylb", RefreshArgs.builder()        
            .keepers(backend.stream().map(element -> element.address()).collect(toList()))
            .serviceName(lb.applyValue(getIpLoadBalancingResult -> getIpLoadBalancingResult.id()))
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_ovh as ovh
import pulumi_ovh as ovh

lb = ovh.IpLoadBalancing.get_ip_load_balancing(service_name="ip-1.2.3.4",
    state="ok")
farmname = ovh.ip_load_balancing.TcpFarm("farmname",
    port=8080,
    service_name=lb.id,
    zone="all")
backend = ovh.ip_load_balancing.TcpFarmServer("backend",
    address="4.5.6.7",
    backup=True,
    display_name="mybackend",
    farm_id=farmname.id,
    port=80,
    probe=True,
    proxy_protocol_version="v2",
    service_name=lb.id,
    ssl=False,
    status="active",
    weight=2)
mylb = ovh.ip_load_balancing.Refresh("mylb",
    keepers=[[__item.address for __item in [backend]]],
    service_name=lb.id)

import * as pulumi from "@pulumi/pulumi";
import * as ovh from "@lbrlabs/pulumi-ovh";
import * as ovh from "@pulumi/ovh";

const lb = ovh.IpLoadBalancing.getIpLoadBalancing({
    serviceName: "ip-1.2.3.4",
    state: "ok",
});
const farmname = new ovh.iploadbalancing.TcpFarm("farmname", {
    port: 8080,
    serviceName: lb.then(lb => lb.id),
    zone: "all",
});
const backend = new ovh.iploadbalancing.TcpFarmServer("backend", {
    address: "4.5.6.7",
    backup: true,
    displayName: "mybackend",
    farmId: farmname.id,
    port: 80,
    probe: true,
    proxyProtocolVersion: "v2",
    serviceName: lb.then(lb => lb.id),
    ssl: false,
    status: "active",
    weight: 2,
});
const mylb = new ovh.iploadbalancing.Refresh("mylb", {
    keepers: [[backend].map(__item => __item.address)],
    serviceName: lb.then(lb => lb.id),
});