Interface 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.

{{% examples %}}

Example Usage

{{% example %}}

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", {
    port: 80,
    protocol: "HTTP",
    vpcId: main.id,
});

import pulumi
import pulumi_aws as aws

main = aws.ec2.Vpc("main", cidr_block="10.0.0.0/16")
test = aws.lb.TargetGroup("test",
    port=80,
    protocol="HTTP",
    vpc_id=main.id)

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()
    {
        Port = 80,
        Protocol = "HTTP",
        VpcId = main.Id,
    });

});

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{
            Port:     pulumi.Int(80),
            Protocol: pulumi.String("HTTP"),
            VpcId:    main.ID(),
        })
        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.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()        
            .port(80)
            .protocol("HTTP")
            .vpcId(main.id())
            .build());

    }
}

resources:
  test:
    type: aws:lb:TargetGroup
    properties:
      port: 80
      protocol: HTTP
      vpcId: ${main.id}
  main:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16

{{% /example %}} {{% example %}}

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", {
    port: 80,
    protocol: "HTTP",
    targetType: "ip",
    vpcId: main.id,
});

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",
    port=80,
    protocol="HTTP",
    target_type="ip",
    vpc_id=main.id)

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()
    {
        Port = 80,
        Protocol = "HTTP",
        TargetType = "ip",
        VpcId = main.Id,
    });

});

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{
            Port:       pulumi.Int(80),
            Protocol:   pulumi.String("HTTP"),
            TargetType: pulumi.String("ip"),
            VpcId:      main.ID(),
        })
        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.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()        
            .port(80)
            .protocol("HTTP")
            .targetType("ip")
            .vpcId(main.id())
            .build());

    }
}

resources:
  ip-example:
    type: aws:lb:TargetGroup
    properties:
      port: 80
      protocol: HTTP
      targetType: ip
      vpcId: ${main.id}
  main:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16

{{% /example %}} {{% example %}}

Lambda Target Group

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const lambda_example = new aws.lb.TargetGroup("lambda-example", {targetType: "lambda"});

import pulumi
import pulumi_aws as aws

lambda_example = aws.lb.TargetGroup("lambda-example", target_type="lambda")

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()
    {
        TargetType = "lambda",
    });

});

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{
            TargetType: pulumi.String("lambda"),
        })
        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.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()        
            .targetType("lambda")
            .build());

    }
}

resources:
  lambda-example:
    type: aws:lb:TargetGroup
    properties:
      targetType: lambda

{{% /example %}} {{% example %}}

ALB Target Group

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const alb_example = new aws.lb.TargetGroup("alb-example", {
    targetType: "alb",
    port: 80,
    protocol: "TCP",
    vpcId: aws_vpc.main.id,
});

import pulumi
import pulumi_aws as aws

alb_example = aws.lb.TargetGroup("alb-example",
    target_type="alb",
    port=80,
    protocol="TCP",
    vpc_id=aws_vpc["main"]["id"])

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()
    {
        TargetType = "alb",
        Port = 80,
        Protocol = "TCP",
        VpcId = aws_vpc.Main.Id,
    });

});

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{
            TargetType: pulumi.String("alb"),
            Port:       pulumi.Int(80),
            Protocol:   pulumi.String("TCP"),
            VpcId:      pulumi.Any(aws_vpc.Main.Id),
        })
        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.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()        
            .targetType("alb")
            .port(80)
            .protocol("TCP")
            .vpcId(aws_vpc.main().id())
            .build());

    }
}

resources:
  alb-example:
    type: aws:lb:TargetGroup
    properties:
      targetType: alb
      port: 80
      protocol: TCP
      vpcId: ${aws_vpc.main.id}

{{% /example %}} {{% example %}}

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", {
    port: 25,
    protocol: "TCP",
    vpcId: aws_vpc.main.id,
    targetHealthStates: [{
        enableUnhealthyConnectionTermination: false,
    }],
});

import pulumi
import pulumi_aws as aws

tcp_example = aws.lb.TargetGroup("tcp-example",
    port=25,
    protocol="TCP",
    vpc_id=aws_vpc["main"]["id"],
    target_health_states=[aws.lb.TargetGroupTargetHealthStateArgs(
        enable_unhealthy_connection_termination=False,
    )])

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()
    {
        Port = 25,
        Protocol = "TCP",
        VpcId = aws_vpc.Main.Id,
        TargetHealthStates = new[]
        {
            new Aws.LB.Inputs.TargetGroupTargetHealthStateArgs
            {
                EnableUnhealthyConnectionTermination = false,
            },
        },
    });

});

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{
            Port:     pulumi.Int(25),
            Protocol: pulumi.String("TCP"),
            VpcId:    pulumi.Any(aws_vpc.Main.Id),
            TargetHealthStates: lb.TargetGroupTargetHealthStateArray{
                &lb.TargetGroupTargetHealthStateArgs{
                    EnableUnhealthyConnectionTermination: pulumi.Bool(false),
                },
            },
        })
        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.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()        
            .port(25)
            .protocol("TCP")
            .vpcId(aws_vpc.main().id())
            .targetHealthStates(TargetGroupTargetHealthStateArgs.builder()
                .enableUnhealthyConnectionTermination(false)
                .build())
            .build());

    }
}

resources:
  tcp-example:
    type: aws:lb:TargetGroup
    properties:
      port: 25
      protocol: TCP
      vpcId: ${aws_vpc.main.id}
      targetHealthStates:
        - enableUnhealthyConnectionTermination: false

{{% /example %}} {{% /examples %}}

Import

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

 $ pulumi import aws:lb/targetGroup:TargetGroup app_front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:targetgroup/app-front-end/20cfe21448b66314
interface TargetGroupArgs {
    connectionTermination?: any;
    deregistrationDelay?: any;
    healthCheck?: any;
    ipAddressType?: any;
    lambdaMultiValueHeadersEnabled?: any;
    loadBalancingAlgorithmType?: any;
    loadBalancingCrossZoneEnabled?: any;
    name?: any;
    namePrefix?: any;
    port?: any;
    preserveClientIp?: any;
    protocol?: any;
    protocolVersion?: any;
    proxyProtocolV2?: any;
    slowStart?: any;
    stickiness?: any;
    tags?: any;
    targetFailovers?: any;
    targetHealthStates?: any;
    targetType?: any;
    vpcId?: any;
}

Properties

connectionTermination? deregistrationDelay? healthCheck? ipAddressType? lambdaMultiValueHeadersEnabled? loadBalancingAlgorithmType? loadBalancingCrossZoneEnabled? name? namePrefix? port? preserveClientIp? protocol? protocolVersion? proxyProtocolV2? slowStart? stickiness? tags? targetFailovers? targetHealthStates? targetType? vpcId?

Properties

Optional connectionTermination

connectionTermination?: any

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

Optional deregistrationDelay

deregistrationDelay?: any

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.

Optional healthCheck

healthCheck?: any

Health Check configuration block. Detailed below.

Optional ipAddressType

ipAddressType?: any

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.

Optional lambdaMultiValueHeadersEnabled

lambdaMultiValueHeadersEnabled?: any

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.

Optional loadBalancingAlgorithmType

loadBalancingAlgorithmType?: any

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

Optional loadBalancingCrossZoneEnabled

loadBalancingCrossZoneEnabled?: any

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".

Optional name

name?: any

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.

Optional namePrefix

namePrefix?: any

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

Optional port

port?: any

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.

Optional preserveClientIp

preserveClientIp?: any

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

Optional protocol

protocol?: any

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.

Optional protocolVersion

protocolVersion?: any

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

Optional proxyProtocolV2

proxyProtocolV2?: any

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

Optional slowStart

slowStart?: any

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.

Optional stickiness

stickiness?: any

Stickiness configuration block. Detailed below.

Optional tags

tags?: any

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.

Optional targetFailovers

targetFailovers?: any

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

Optional targetHealthStates

targetHealthStates?: any

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.

Optional targetType

targetType?: any

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.

Optional vpcId

vpcId?: any

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.

Settings

Member Visibility

Theme

On This Page

connectionTerminationderegistrationDelayhealthCheckipAddressTypelambdaMultiValueHeadersEnabledloadBalancingAlgorithmTypeloadBalancingCrossZoneEnablednamenamePrefixportpreserveClientIpprotocolprotocolVersionproxyProtocolV2slowStartstickinesstagstargetFailoverstargetHealthStatestargetTypevpcId

Generated using TypeDoc