exoscale.NlbService

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

return await Deployment.RunAsync(() => 
{
    var myNlb = new Exoscale.Nlb("myNlb", new()
    {
        Zone = "ch-gva-2",
    });

    var myNlbService = new Exoscale.NlbService("myNlbService", new()
    {
        NlbId = myNlb.Id,
        Zone = myNlb.Zone,
        InstancePoolId = exoscale_instance_pool.My_instance_pool.Id,
        Protocol = "tcp",
        Port = 443,
        TargetPort = 8443,
        Strategy = "round-robin",
        Healthchecks = new[]
        {
            new Exoscale.Inputs.NlbServiceHealthcheckArgs
            {
                Mode = "https",
                Port = 8443,
                Uri = "/healthz",
                TlsSni = "example.net",
                Interval = 5,
                Timeout = 3,
                Retries = 1,
            },
        },
    });

});

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.NewNlb(ctx, "myNlb", &exoscale.NlbArgs{
			Zone: pulumi.String("ch-gva-2"),
		})
		if err != nil {
			return err
		}
		_, err = exoscale.NewNlbService(ctx, "myNlbService", &exoscale.NlbServiceArgs{
			NlbId:          myNlb.ID(),
			Zone:           myNlb.Zone,
			InstancePoolId: pulumi.Any(exoscale_instance_pool.My_instance_pool.Id),
			Protocol:       pulumi.String("tcp"),
			Port:           pulumi.Int(443),
			TargetPort:     pulumi.Int(8443),
			Strategy:       pulumi.String("round-robin"),
			Healthchecks: exoscale.NlbServiceHealthcheckArray{
				&exoscale.NlbServiceHealthcheckArgs{
					Mode:     pulumi.String("https"),
					Port:     pulumi.Int(8443),
					Uri:      pulumi.String("/healthz"),
					TlsSni:   pulumi.String("example.net"),
					Interval: pulumi.Int(5),
					Timeout:  pulumi.Int(3),
					Retries:  pulumi.Int(1),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.exoscale.Nlb;
import com.pulumi.exoscale.NlbArgs;
import com.pulumi.exoscale.NlbService;
import com.pulumi.exoscale.NlbServiceArgs;
import com.pulumi.exoscale.inputs.NlbServiceHealthcheckArgs;
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 myNlb = new Nlb("myNlb", NlbArgs.builder()        
            .zone("ch-gva-2")
            .build());

        var myNlbService = new NlbService("myNlbService", NlbServiceArgs.builder()        
            .nlbId(myNlb.id())
            .zone(myNlb.zone())
            .instancePoolId(exoscale_instance_pool.my_instance_pool().id())
            .protocol("tcp")
            .port(443)
            .targetPort(8443)
            .strategy("round-robin")
            .healthchecks(NlbServiceHealthcheckArgs.builder()
                .mode("https")
                .port(8443)
                .uri("/healthz")
                .tlsSni("example.net")
                .interval(5)
                .timeout(3)
                .retries(1)
                .build())
            .build());

    }
}

import pulumi
import pulumiverse_exoscale as exoscale

my_nlb = exoscale.Nlb("myNlb", zone="ch-gva-2")
my_nlb_service = exoscale.NlbService("myNlbService",
    nlb_id=my_nlb.id,
    zone=my_nlb.zone,
    instance_pool_id=exoscale_instance_pool["my_instance_pool"]["id"],
    protocol="tcp",
    port=443,
    target_port=8443,
    strategy="round-robin",
    healthchecks=[exoscale.NlbServiceHealthcheckArgs(
        mode="https",
        port=8443,
        uri="/healthz",
        tls_sni="example.net",
        interval=5,
        timeout=3,
        retries=1,
    )])

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

const myNlb = new exoscale.Nlb("myNlb", {zone: "ch-gva-2"});
const myNlbService = new exoscale.NlbService("myNlbService", {
    nlbId: myNlb.id,
    zone: myNlb.zone,
    instancePoolId: exoscale_instance_pool.my_instance_pool.id,
    protocol: "tcp",
    port: 443,
    targetPort: 8443,
    strategy: "round-robin",
    healthchecks: [{
        mode: "https",
        port: 8443,
        uri: "/healthz",
        tlsSni: "example.net",
        interval: 5,
        timeout: 3,
        retries: 1,
    }],
});

resources:
  myNlb:
    type: exoscale:Nlb
    properties:
      zone: ch-gva-2
  myNlbService:
    type: exoscale:NlbService
    properties:
      nlbId: ${myNlb.id}
      zone: ${myNlb.zone}
      instancePoolId: ${exoscale_instance_pool.my_instance_pool.id}
      protocol: tcp
      port: 443
      targetPort: 8443
      strategy: round-robin
      healthchecks:
        - mode: https
          port: 8443
          uri: /healthz
          tlsSni: example.net
          interval: 5
          timeout: 3
          retries: 1