pulumi-aws-kotlin/com.pulumi.aws.alb.kotlin/TargetGroupArgs

TargetGroupArgs

data class TargetGroupArgs(val connectionTermination: Output<Boolean>? = null, val deregistrationDelay: Output<Int>? = null, val healthCheck: Output<TargetGroupHealthCheckArgs>? = null, val ipAddressType: Output<String>? = null, val lambdaMultiValueHeadersEnabled: Output<Boolean>? = null, val loadBalancingAlgorithmType: Output<String>? = null, val loadBalancingAnomalyMitigation: Output<String>? = null, val loadBalancingCrossZoneEnabled: Output<String>? = null, val name: Output<String>? = null, val namePrefix: Output<String>? = null, val port: Output<Int>? = null, val preserveClientIp: Output<String>? = null, val protocol: Output<String>? = null, val protocolVersion: Output<String>? = null, val proxyProtocolV2: Output<Boolean>? = null, val slowStart: Output<Int>? = null, val stickiness: Output<TargetGroupStickinessArgs>? = null, val tags: Output<Map<String, String>>? = null, val targetFailovers: Output<List<TargetGroupTargetFailoverArgs>>? = null, val targetHealthStates: Output<List<TargetGroupTargetHealthStateArgs>>? = null, val targetType: Output<String>? = null, val vpcId: Output<String>? = null) : ConvertibleToJava<TargetGroupArgs>

Provides a Target Group resource for use with Load Balancer resources.

Note: aws.alb.TargetGroup is known as aws.lb.TargetGroup. The functionality is identical.

Example Usage

Instance Target Group

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const main = new aws.ec2.Vpc("main", {cidrBlock: "10.0.0.0/16"});
const test = new aws.lb.TargetGroup("test", {
    name: "tf-example-lb-tg",
    port: 80,
    protocol: "HTTP",
    vpcId: main.id,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
main = aws.ec2.Vpc("main", cidr_block="10.0.0.0/16")
test = aws.lb.TargetGroup("test",
    name="tf-example-lb-tg",
    port=80,
    protocol="HTTP",
    vpc_id=main.id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var main = new Aws.Ec2.Vpc("main", new()
    {
        CidrBlock = "10.0.0.0/16",
    });
    var test = new Aws.LB.TargetGroup("test", new()
    {
        Name = "tf-example-lb-tg",
        Port = 80,
        Protocol = "HTTP",
        VpcId = main.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := ec2.NewVpc(ctx, "main", &ec2.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		_, err = lb.NewTargetGroup(ctx, "test", &lb.TargetGroupArgs{
			Name:     pulumi.String("tf-example-lb-tg"),
			Port:     pulumi.Int(80),
			Protocol: pulumi.String("HTTP"),
			VpcId:    main.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.TargetGroupArgs;
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 main = new Vpc("main", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .build());
        var test = new TargetGroup("test", TargetGroupArgs.builder()
            .name("tf-example-lb-tg")
            .port(80)
            .protocol("HTTP")
            .vpcId(main.id())
            .build());
    }
}
Content copied to clipboard
resources:
  test:
    type: aws:lb:TargetGroup
    properties:
      name: tf-example-lb-tg
      port: 80
      protocol: HTTP
      vpcId: ${main.id}
  main:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
Content copied to clipboard

IP Target Group

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const main = new aws.ec2.Vpc("main", {cidrBlock: "10.0.0.0/16"});
const ip_example = new aws.lb.TargetGroup("ip-example", {
    name: "tf-example-lb-tg",
    port: 80,
    protocol: "HTTP",
    targetType: "ip",
    vpcId: main.id,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
main = aws.ec2.Vpc("main", cidr_block="10.0.0.0/16")
ip_example = aws.lb.TargetGroup("ip-example",
    name="tf-example-lb-tg",
    port=80,
    protocol="HTTP",
    target_type="ip",
    vpc_id=main.id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var main = new Aws.Ec2.Vpc("main", new()
    {
        CidrBlock = "10.0.0.0/16",
    });
    var ip_example = new Aws.LB.TargetGroup("ip-example", new()
    {
        Name = "tf-example-lb-tg",
        Port = 80,
        Protocol = "HTTP",
        TargetType = "ip",
        VpcId = main.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := ec2.NewVpc(ctx, "main", &ec2.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		_, err = lb.NewTargetGroup(ctx, "ip-example", &lb.TargetGroupArgs{
			Name:       pulumi.String("tf-example-lb-tg"),
			Port:       pulumi.Int(80),
			Protocol:   pulumi.String("HTTP"),
			TargetType: pulumi.String("ip"),
			VpcId:      main.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.TargetGroupArgs;
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 main = new Vpc("main", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .build());
        var ip_example = new TargetGroup("ip-example", TargetGroupArgs.builder()
            .name("tf-example-lb-tg")
            .port(80)
            .protocol("HTTP")
            .targetType("ip")
            .vpcId(main.id())
            .build());
    }
}
Content copied to clipboard
resources:
  ip-example:
    type: aws:lb:TargetGroup
    properties:
      name: tf-example-lb-tg
      port: 80
      protocol: HTTP
      targetType: ip
      vpcId: ${main.id}
  main:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
Content copied to clipboard

Lambda Target Group

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const lambda_example = new aws.lb.TargetGroup("lambda-example", {
    name: "tf-example-lb-tg",
    targetType: "lambda",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
lambda_example = aws.lb.TargetGroup("lambda-example",
    name="tf-example-lb-tg",
    target_type="lambda")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var lambda_example = new Aws.LB.TargetGroup("lambda-example", new()
    {
        Name = "tf-example-lb-tg",
        TargetType = "lambda",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lb.NewTargetGroup(ctx, "lambda-example", &lb.TargetGroupArgs{
			Name:       pulumi.String("tf-example-lb-tg"),
			TargetType: pulumi.String("lambda"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.TargetGroupArgs;
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 lambda_example = new TargetGroup("lambda-example", TargetGroupArgs.builder()
            .name("tf-example-lb-tg")
            .targetType("lambda")
            .build());
    }
}
Content copied to clipboard
resources:
  lambda-example:
    type: aws:lb:TargetGroup
    properties:
      name: tf-example-lb-tg
      targetType: lambda
Content copied to clipboard

ALB Target Group

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const alb_example = new aws.lb.TargetGroup("alb-example", {
    name: "tf-example-lb-alb-tg",
    targetType: "alb",
    port: 80,
    protocol: "TCP",
    vpcId: main.id,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
alb_example = aws.lb.TargetGroup("alb-example",
    name="tf-example-lb-alb-tg",
    target_type="alb",
    port=80,
    protocol="TCP",
    vpc_id=main["id"])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var alb_example = new Aws.LB.TargetGroup("alb-example", new()
    {
        Name = "tf-example-lb-alb-tg",
        TargetType = "alb",
        Port = 80,
        Protocol = "TCP",
        VpcId = main.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lb.NewTargetGroup(ctx, "alb-example", &lb.TargetGroupArgs{
			Name:       pulumi.String("tf-example-lb-alb-tg"),
			TargetType: pulumi.String("alb"),
			Port:       pulumi.Int(80),
			Protocol:   pulumi.String("TCP"),
			VpcId:      pulumi.Any(main.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.TargetGroupArgs;
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 alb_example = new TargetGroup("alb-example", TargetGroupArgs.builder()
            .name("tf-example-lb-alb-tg")
            .targetType("alb")
            .port(80)
            .protocol("TCP")
            .vpcId(main.id())
            .build());
    }
}
Content copied to clipboard
resources:
  alb-example:
    type: aws:lb:TargetGroup
    properties:
      name: tf-example-lb-alb-tg
      targetType: alb
      port: 80
      protocol: TCP
      vpcId: ${main.id}
Content copied to clipboard

Target group with unhealthy connection termination disabled

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const tcp_example = new aws.lb.TargetGroup("tcp-example", {
    name: "tf-example-lb-nlb-tg",
    port: 25,
    protocol: "TCP",
    vpcId: main.id,
    targetHealthStates: [{
        enableUnhealthyConnectionTermination: false,
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
tcp_example = aws.lb.TargetGroup("tcp-example",
    name="tf-example-lb-nlb-tg",
    port=25,
    protocol="TCP",
    vpc_id=main["id"],
    target_health_states=[aws.lb.TargetGroupTargetHealthStateArgs(
        enable_unhealthy_connection_termination=False,
    )])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var tcp_example = new Aws.LB.TargetGroup("tcp-example", new()
    {
        Name = "tf-example-lb-nlb-tg",
        Port = 25,
        Protocol = "TCP",
        VpcId = main.Id,
        TargetHealthStates = new[]
        {
            new Aws.LB.Inputs.TargetGroupTargetHealthStateArgs
            {
                EnableUnhealthyConnectionTermination = false,
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lb.NewTargetGroup(ctx, "tcp-example", &lb.TargetGroupArgs{
			Name:     pulumi.String("tf-example-lb-nlb-tg"),
			Port:     pulumi.Int(25),
			Protocol: pulumi.String("TCP"),
			VpcId:    pulumi.Any(main.Id),
			TargetHealthStates: lb.TargetGroupTargetHealthStateArray{
				&lb.TargetGroupTargetHealthStateArgs{
					EnableUnhealthyConnectionTermination: pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.TargetGroupArgs;
import com.pulumi.aws.lb.inputs.TargetGroupTargetHealthStateArgs;
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 tcp_example = new TargetGroup("tcp-example", TargetGroupArgs.builder()
            .name("tf-example-lb-nlb-tg")
            .port(25)
            .protocol("TCP")
            .vpcId(main.id())
            .targetHealthStates(TargetGroupTargetHealthStateArgs.builder()
                .enableUnhealthyConnectionTermination(false)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  tcp-example:
    type: aws:lb:TargetGroup
    properties:
      name: tf-example-lb-nlb-tg
      port: 25
      protocol: TCP
      vpcId: ${main.id}
      targetHealthStates:
        - enableUnhealthyConnectionTermination: false
Content copied to clipboard

Import

Using pulumi import, import Target Groups using their ARN. For example:

$ pulumi import aws:alb/targetGroup:TargetGroup app_front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:targetgroup/app-front-end/20cfe21448b66314
Content copied to clipboard

Constructors

Link copied to clipboard
fun TargetGroupArgs(connectionTermination: Output<Boolean>? = null, deregistrationDelay: Output<Int>? = null, healthCheck: Output<TargetGroupHealthCheckArgs>? = null, ipAddressType: Output<String>? = null, lambdaMultiValueHeadersEnabled: Output<Boolean>? = null, loadBalancingAlgorithmType: Output<String>? = null, loadBalancingAnomalyMitigation: Output<String>? = null, loadBalancingCrossZoneEnabled: Output<String>? = null, name: Output<String>? = null, namePrefix: Output<String>? = null, port: Output<Int>? = null, preserveClientIp: Output<String>? = null, protocol: Output<String>? = null, protocolVersion: Output<String>? = null, proxyProtocolV2: Output<Boolean>? = null, slowStart: Output<Int>? = null, stickiness: Output<TargetGroupStickinessArgs>? = null, tags: Output<Map<String, String>>? = null, targetFailovers: Output<List<TargetGroupTargetFailoverArgs>>? = null, targetHealthStates: Output<List<TargetGroupTargetHealthStateArgs>>? = null, targetType: Output<String>? = null, vpcId: Output<String>? = null)

Functions

Link copied to clipboard
open override fun toJava(): TargetGroupArgs

Properties

Link copied to clipboard
val connectionTermination: Output<Boolean>? = null

Whether to terminate connections at the end of the deregistration timeout on Network Load Balancers. See doc for more information. Default is false.

Link copied to clipboard
val deregistrationDelay: Output<Int>? = null

Amount time for Elastic Load Balancing to wait before changing the state of a deregistering target from draining to unused. The range is 0-3600 seconds. The default value is 300 seconds.

Link copied to clipboard
val healthCheck: Output<TargetGroupHealthCheckArgs>? = null

Health Check configuration block. Detailed below.

Link copied to clipboard
val ipAddressType: Output<String>? = null

The type of IP addresses used by the target group, only supported when target type is set to ip. Possible values are ipv4 or ipv6.

Link copied to clipboard
val lambdaMultiValueHeadersEnabled: Output<Boolean>? = null

Whether the request and response headers exchanged between the load balancer and the Lambda function include arrays of values or strings. Only applies when target_type is lambda. Default is false.

Link copied to clipboard
val loadBalancingAlgorithmType: Output<String>? = null

Determines how the load balancer selects targets when routing requests. Only applicable for Application Load Balancer Target Groups. The value is round_robin, least_outstanding_requests, or weighted_random. The default is round_robin.

Link copied to clipboard
val loadBalancingAnomalyMitigation: Output<String>? = null

Determines whether to enable target anomaly mitigation. Target anomaly mitigation is only supported by the weighted_random load balancing algorithm type. See doc for more information. The value is "on" or "off". The default is "off".

Link copied to clipboard
val loadBalancingCrossZoneEnabled: Output<String>? = null

Indicates whether cross zone load balancing is enabled. The value is "true", "false" or "use_load_balancer_configuration". The default is "use_load_balancer_configuration".

Link copied to clipboard
val name: Output<String>? = null

Name of the target group. If omitted, this provider will assign a random, unique name. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen.

Link copied to clipboard
val namePrefix: Output<String>? = null

Creates a unique name beginning with the specified prefix. Conflicts with name. Cannot be longer than 6 characters.

Link copied to clipboard
val port: Output<Int>? = null

Port on which targets receive traffic, unless overridden when registering a specific target. Required when target_type is instance, ip or alb. Does not apply when target_type is lambda.

Link copied to clipboard
val preserveClientIp: Output<String>? = null

Whether client IP preservation is enabled. See doc for more information.

Link copied to clipboard
val protocol: Output<String>? = null

Protocol to use for routing traffic to the targets. Should be one of GENEVE, HTTP, HTTPS, TCP, TCP_UDP, TLS, or UDP. Required when target_type is instance, ip, or alb. Does not apply when target_type is lambda.

Link copied to clipboard
val protocolVersion: Output<String>? = null

Only applicable when protocol is HTTP or HTTPS. The protocol version. Specify GRPC to send requests to targets using gRPC. Specify HTTP2 to send requests to targets using HTTP/2. The default is HTTP1, which sends requests to targets using HTTP/1.1

Link copied to clipboard
val proxyProtocolV2: Output<Boolean>? = null

Whether to enable support for proxy protocol v2 on Network Load Balancers. See doc for more information. Default is false.

Link copied to clipboard
val slowStart: Output<Int>? = null

Amount time for targets to warm up before the load balancer sends them a full share of requests. The range is 30-900 seconds or 0 to disable. The default value is 0 seconds.

Link copied to clipboard
val stickiness: Output<TargetGroupStickinessArgs>? = null

Stickiness configuration block. Detailed below.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Map of tags to assign to the resource. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val targetFailovers: Output<List<TargetGroupTargetFailoverArgs>>? = null

Target failover block. Only applicable for Gateway Load Balancer target groups. See target_failover for more information.

Link copied to clipboard
val targetHealthStates: Output<List<TargetGroupTargetHealthStateArgs>>? = null

Target health state block. Only applicable for Network Load Balancer target groups when protocol is TCP or TLS. See target_health_state for more information.

Link copied to clipboard
val targetType: Output<String>? = null

Type of target that you must specify when registering targets with this target group. See doc for supported values. The default is instance. Note that you can't specify targets for a target group using both instance IDs and IP addresses. If the target type is ip, specify IP addresses from the subnets of the virtual private cloud (VPC) for the target group, the RFC 1918 range (10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16), and the RFC 6598 range (100.64.0.0/10). You can't specify publicly routable IP addresses. Network Load Balancers do not support the lambda target type. Application Load Balancers do not support the alb target type.

Link copied to clipboard
val vpcId: Output<String>? = null

Identifier of the VPC in which to create the target group. Required when target_type is instance, ip or alb. Does not apply when target_type is lambda.