From bdb26a1b8d3b088bf0d50d2848d5fc06646cde6e Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Fri, 20 Oct 2023 11:58:18 -0400 Subject: [PATCH 1/8] [WIP] Add to schema and CRUD --- internal/service/elbv2/target_group.go | 53 ++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/internal/service/elbv2/target_group.go b/internal/service/elbv2/target_group.go index bacb8ca2bdb..9368a6733c9 100644 --- a/internal/service/elbv2/target_group.go +++ b/internal/service/elbv2/target_group.go @@ -291,6 +291,19 @@ func ResourceTargetGroup() *schema.Resource { }, names.AttrTags: tftags.TagsSchema(), names.AttrTagsAll: tftags.TagsSchemaComputed(), + "target_health_state": { + Type: schema.TypeList, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "enable_unhealthy_connection_termination": { + Type: schema.TypeBool, + Optional: true, + Default: true, + }, + }, + }, + }, "target_failover": { Type: schema.TypeList, Optional: true, @@ -537,6 +550,17 @@ func resourceTargetGroupCreate(ctx context.Context, d *schema.ResourceData, meta } } + if v, ok := d.GetOk("target_health_state"); ok && len(v.([]interface{})) > 0 { + targetHealthStateBlock := v.([]interface{}) + targetHealthState := targetHealthStateBlock[0].(map[string]interface{}) + attrs = append(attrs, + &elbv2.TargetGroupAttribute{ + Key: aws.String("target_health_state.unhealthy.connection_termination.enabled"), + Value: aws.String(strconv.FormatBool(targetHealthState["enable_unhealthy_connection_termination"].(bool))), + }, + ) + } + if v, ok := d.GetOk("stickiness"); ok && len(v.([]interface{})) > 0 { stickinessBlocks := v.([]interface{}) stickiness := stickinessBlocks[0].(map[string]interface{}) @@ -1102,6 +1126,14 @@ func flattenTargetGroupResource(ctx context.Context, d *schema.ResourceData, met return fmt.Errorf("setting stickiness: %w", err) } + targetHealthStateAttr, err := flattenTargetHealthState(attrResp.Attributes) + if err != nil { + return fmt.Errorf("flattening target health state: %w", err) + } + if err := d.Set("target_health_state", targetHealthStateAttr); err != nil { + return fmt.Errorf("setting target health state: %w", err) + } + // Set target failover attributes for GWLB targetFailoverAttr := flattenTargetGroupFailover(attrResp.Attributes) if err != nil { @@ -1115,6 +1147,27 @@ func flattenTargetGroupResource(ctx context.Context, d *schema.ResourceData, met return nil } +func flattenTargetHealthState(attributes []*elbv2.TargetGroupAttribute) ([]interface{}, error) { + if len(attributes) == 0 { + return []interface{}{}, nil + } + + m := make(map[string]interface{}) + + for _, attr := range attributes { + switch aws.StringValue(attr.Key) { + case "target_health_state.unhealthy.connection_termination": + enabled, err := strconv.ParseBool(aws.StringValue(attr.Value)) + if err != nil { + return nil, fmt.Errorf("converting target_health_state.unhealthy.connection_termination to bool: %s", aws.StringValue(attr.Value)) + } + m["enable_unhealthy_connection_termination"] = enabled + } + } + + return []interface{}{m}, nil +} + func flattenTargetGroupFailover(attributes []*elbv2.TargetGroupAttribute) []interface{} { if len(attributes) == 0 { return []interface{}{} From 4c4be6aef29730cd6dc0e8109e29948391c09a1b Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Fri, 20 Oct 2023 12:25:28 -0400 Subject: [PATCH 2/8] [WIP] Add acceptance tests --- internal/service/elbv2/target_group_test.go | 71 +++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/internal/service/elbv2/target_group_test.go b/internal/service/elbv2/target_group_test.go index 4255019b8ad..2f6b7d1a900 100644 --- a/internal/service/elbv2/target_group_test.go +++ b/internal/service/elbv2/target_group_test.go @@ -2342,6 +2342,54 @@ func TestAccELBV2TargetGroup_ALBAlias_updateStickinessEnabled(t *testing.T) { }) } +func TestAccELBV2LoadBalancer_targetHealthStateUnhealthyConnectionTermination(t *testing.T) { + ctx := acctest.Context(t) + var targetGroup elbv2.TargetGroup + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + resourceName := "aws_lb_target_group.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, elbv2.EndpointsID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + CheckDestroy: testAccCheckTargetGroupDestroy(ctx), + Steps: []resource.TestStep{ + { + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP", true), + Check: resource.ComposeAggregateTestCheckFunc( + testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), + resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), + ), + }, + { + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP", false), + Check: resource.ComposeAggregateTestCheckFunc( + testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), + resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "false"), + ), + }, + { + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "UDP", true), + Check: resource.ComposeAggregateTestCheckFunc( + testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), + resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), + ), + }, + { + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP_UDP", true), + Check: resource.ComposeAggregateTestCheckFunc( + testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), + resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), + ), + }, + }, + }) +} + func testAccCheckTargetGroupDestroy(ctx context.Context) resource.TestCheckFunc { return func(s *terraform.State) error { conn := acctest.Provider.Meta().(*conns.AWSClient).ELBV2Conn(ctx) @@ -3118,6 +3166,29 @@ resource "aws_vpc" "test" { `, protocol, stickyType, enabled, rName) } +func testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, protocol string, enabled bool) string { + return fmt.Sprintf(` +resource "aws_lb_target_group" "test" { + name_prefix = "tf-" + port = 25 + protocol = %[1]q + vpc_id = aws_vpc.test.id + + target_health_state { + enable_unhealthy_connection_termination = %[2]t + } +} + +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" + + tags = { + Name = %[3]q + } +} +`, protocol, enabled, rName) +} + func testAccTargetGroupConfig_typeTCP(rName string) string { return fmt.Sprintf(` resource "aws_lb_target_group" "test" { From dfef653b4159163c1cedee8208e40cd4c66d913b Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Fri, 20 Oct 2023 17:06:46 -0400 Subject: [PATCH 3/8] [WIP] Acceptance tests --- internal/service/elbv2/target_group.go | 64 +++++++++++++-------- internal/service/elbv2/target_group_test.go | 32 +++++++---- 2 files changed, 61 insertions(+), 35 deletions(-) diff --git a/internal/service/elbv2/target_group.go b/internal/service/elbv2/target_group.go index 9368a6733c9..fd3c3cd1347 100644 --- a/internal/service/elbv2/target_group.go +++ b/internal/service/elbv2/target_group.go @@ -291,19 +291,6 @@ func ResourceTargetGroup() *schema.Resource { }, names.AttrTags: tftags.TagsSchema(), names.AttrTagsAll: tftags.TagsSchemaComputed(), - "target_health_state": { - Type: schema.TypeList, - Optional: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "enable_unhealthy_connection_termination": { - Type: schema.TypeBool, - Optional: true, - Default: true, - }, - }, - }, - }, "target_failover": { Type: schema.TypeList, Optional: true, @@ -329,6 +316,19 @@ func ResourceTargetGroup() *schema.Resource { }, }, }, + "target_health_state": { + Type: schema.TypeList, + Optional: true, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "enable_unhealthy_connection_termination": { + Type: schema.TypeBool, + Required: true, + }, + }, + }, + }, "target_type": { Type: schema.TypeString, Optional: true, @@ -550,15 +550,21 @@ func resourceTargetGroupCreate(ctx context.Context, d *schema.ResourceData, meta } } - if v, ok := d.GetOk("target_health_state"); ok && len(v.([]interface{})) > 0 { - targetHealthStateBlock := v.([]interface{}) - targetHealthState := targetHealthStateBlock[0].(map[string]interface{}) - attrs = append(attrs, - &elbv2.TargetGroupAttribute{ - Key: aws.String("target_health_state.unhealthy.connection_termination.enabled"), - Value: aws.String(strconv.FormatBool(targetHealthState["enable_unhealthy_connection_termination"].(bool))), - }, - ) + // Only supported for TCP & TLS protocols + if v, ok := d.Get("protocol").(string); ok { + if v == elbv2.ProtocolEnumTcp || v == elbv2.ProtocolEnumTls { + fmt.Println("Protocol type", v) + if v, ok := d.GetOk("target_health_state"); ok && len(v.([]interface{})) > 0 { + targetHealthStateBlock := v.([]interface{}) + targetHealthState := targetHealthStateBlock[0].(map[string]interface{}) + attrs = append(attrs, + &elbv2.TargetGroupAttribute{ + Key: aws.String("target_health_state.unhealthy.connection_termination.enabled"), + Value: aws.String(strconv.FormatBool(targetHealthState["enable_unhealthy_connection_termination"].(bool))), + }, + ) + } + } } if v, ok := d.GetOk("stickiness"); ok && len(v.([]interface{})) > 0 { @@ -813,6 +819,18 @@ func resourceTargetGroupUpdate(ctx context.Context, d *schema.ResourceData, meta }) } + if d.HasChange("target_health_state") { + targetHealthStateBlock := d.Get("target_health_state").([]interface{}) + if len(targetHealthStateBlock) == 1 { + targetHealthState := targetHealthStateBlock[0].(map[string]interface{}) + attrs = append(attrs, + &elbv2.TargetGroupAttribute{ + Key: aws.String("target_health_state.unhealthy.connection_termination.enabled"), + Value: aws.String(strconv.FormatBool(targetHealthState["enable_unhealthy_connection_termination"].(bool))), + }) + } + } + if d.HasChange("target_failover") { failoverBlock := d.Get("target_failover").([]interface{}) if len(failoverBlock) == 1 { @@ -1156,7 +1174,7 @@ func flattenTargetHealthState(attributes []*elbv2.TargetGroupAttribute) ([]inter for _, attr := range attributes { switch aws.StringValue(attr.Key) { - case "target_health_state.unhealthy.connection_termination": + case "target_health_state.unhealthy.connection_termination.enabled": enabled, err := strconv.ParseBool(aws.StringValue(attr.Value)) if err != nil { return nil, fmt.Errorf("converting target_health_state.unhealthy.connection_termination to bool: %s", aws.StringValue(attr.Value)) diff --git a/internal/service/elbv2/target_group_test.go b/internal/service/elbv2/target_group_test.go index 2f6b7d1a900..0be47cbaff2 100644 --- a/internal/service/elbv2/target_group_test.go +++ b/internal/service/elbv2/target_group_test.go @@ -2355,34 +2355,42 @@ func TestAccELBV2LoadBalancer_targetHealthStateUnhealthyConnectionTermination(t CheckDestroy: testAccCheckTargetGroupDestroy(ctx), Steps: []resource.TestStep{ { - Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP", true), + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP", false), Check: resource.ComposeAggregateTestCheckFunc( testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), resource.TestCheckResourceAttr(resourceName, "name", rName), - resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), + resource.TestCheckResourceAttr(resourceName, "protocol", "TCP"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.#", "1"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "false"), ), }, { - Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP", false), + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP", true), Check: resource.ComposeAggregateTestCheckFunc( testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), resource.TestCheckResourceAttr(resourceName, "name", rName), - resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "false"), + resource.TestCheckResourceAttr(resourceName, "protocol", "TCP"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.#", "1"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), ), }, { - Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "UDP", true), + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TLS", false), Check: resource.ComposeAggregateTestCheckFunc( testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), resource.TestCheckResourceAttr(resourceName, "name", rName), - resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), + resource.TestCheckResourceAttr(resourceName, "protocol", "TLS"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.#", "1"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "false"), ), }, { - Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TCP_UDP", true), + Config: testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, "TLS", true), Check: resource.ComposeAggregateTestCheckFunc( testAccCheckTargetGroupExists(ctx, resourceName, &targetGroup), resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "protocol", "TLS"), + resource.TestCheckResourceAttr(resourceName, "target_health_state.#", "1"), resource.TestCheckResourceAttr(resourceName, "target_health_state.0.enable_unhealthy_connection_termination", "true"), ), }, @@ -3169,13 +3177,13 @@ resource "aws_vpc" "test" { func testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, protocol string, enabled bool) string { return fmt.Sprintf(` resource "aws_lb_target_group" "test" { - name_prefix = "tf-" + name = %[1]q port = 25 - protocol = %[1]q + protocol = %[2]q vpc_id = aws_vpc.test.id target_health_state { - enable_unhealthy_connection_termination = %[2]t + enable_unhealthy_connection_termination = %[3]t } } @@ -3183,10 +3191,10 @@ resource "aws_vpc" "test" { cidr_block = "10.0.0.0/16" tags = { - Name = %[3]q + Name = %[1]q } } -`, protocol, enabled, rName) +`, rName, protocol, enabled) } func testAccTargetGroupConfig_typeTCP(rName string) string { From b6950dce7d0fef33d4f8df955182605c0e1bf852 Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Mon, 23 Oct 2023 10:23:39 -0400 Subject: [PATCH 4/8] Update connection_termination attribute --- internal/service/elbv2/target_group.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/service/elbv2/target_group.go b/internal/service/elbv2/target_group.go index fd3c3cd1347..e9ee6b82d68 100644 --- a/internal/service/elbv2/target_group.go +++ b/internal/service/elbv2/target_group.go @@ -67,7 +67,7 @@ func ResourceTargetGroup() *schema.Resource { "connection_termination": { Type: schema.TypeBool, Optional: true, - Default: false, + Computed: true, }, "deregistration_delay": { Type: nullable.TypeNullableInt, From 67d6420baee2ede3b17c56a6292d66884284ece8 Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Mon, 23 Oct 2023 11:10:57 -0400 Subject: [PATCH 5/8] Run linters --- internal/service/elbv2/target_group.go | 1 - internal/service/elbv2/target_group_test.go | 10 +++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/internal/service/elbv2/target_group.go b/internal/service/elbv2/target_group.go index e9ee6b82d68..3c510e710bb 100644 --- a/internal/service/elbv2/target_group.go +++ b/internal/service/elbv2/target_group.go @@ -553,7 +553,6 @@ func resourceTargetGroupCreate(ctx context.Context, d *schema.ResourceData, meta // Only supported for TCP & TLS protocols if v, ok := d.Get("protocol").(string); ok { if v == elbv2.ProtocolEnumTcp || v == elbv2.ProtocolEnumTls { - fmt.Println("Protocol type", v) if v, ok := d.GetOk("target_health_state"); ok && len(v.([]interface{})) > 0 { targetHealthStateBlock := v.([]interface{}) targetHealthState := targetHealthStateBlock[0].(map[string]interface{}) diff --git a/internal/service/elbv2/target_group_test.go b/internal/service/elbv2/target_group_test.go index 0be47cbaff2..f35aeb0ecd4 100644 --- a/internal/service/elbv2/target_group_test.go +++ b/internal/service/elbv2/target_group_test.go @@ -2342,7 +2342,7 @@ func TestAccELBV2TargetGroup_ALBAlias_updateStickinessEnabled(t *testing.T) { }) } -func TestAccELBV2LoadBalancer_targetHealthStateUnhealthyConnectionTermination(t *testing.T) { +func TestAccELBV2TargetGroup_targetHealthStateUnhealthyConnectionTermination(t *testing.T) { ctx := acctest.Context(t) var targetGroup elbv2.TargetGroup rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) @@ -3177,10 +3177,10 @@ resource "aws_vpc" "test" { func testAccTargetGroupConfig_targetHealthStateConnectionTermination(rName, protocol string, enabled bool) string { return fmt.Sprintf(` resource "aws_lb_target_group" "test" { - name = %[1]q - port = 25 - protocol = %[2]q - vpc_id = aws_vpc.test.id + name = %[1]q + port = 25 + protocol = %[2]q + vpc_id = aws_vpc.test.id target_health_state { enable_unhealthy_connection_termination = %[3]t From be99ad74c4c57ef399f270c8308552e275c5f9db Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Mon, 23 Oct 2023 11:33:22 -0400 Subject: [PATCH 6/8] Add changelog --- .changelog/34070.txt | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 .changelog/34070.txt diff --git a/.changelog/34070.txt b/.changelog/34070.txt new file mode 100644 index 00000000000..72ee32e66db --- /dev/null +++ b/.changelog/34070.txt @@ -0,0 +1,4 @@ +```release-note:enhancement +resource/aws_lb_target_group: Add `target_health_state` block with attribute `enable_unhealthy_connection_termination` to disabling connection termination for unhealthy targets on NLB +resource/aws_lb_target_group: Removes the default `false` value for the `connection_termination` attribute to support new default behavior for UDP/TCP_UDP target groups +``` \ No newline at end of file From 32a2dd5e5a4cebac90ec71431bc8a48318c74098 Mon Sep 17 00:00:00 2001 From: Dave DeRicco <30156588+ddericco@users.noreply.github.com> Date: Mon, 23 Oct 2023 11:55:24 -0400 Subject: [PATCH 7/8] Add docs --- website/docs/r/lb_target_group.html.markdown | 22 ++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/website/docs/r/lb_target_group.html.markdown b/website/docs/r/lb_target_group.html.markdown index f520553928b..556d6518bd3 100644 --- a/website/docs/r/lb_target_group.html.markdown +++ b/website/docs/r/lb_target_group.html.markdown @@ -66,6 +66,21 @@ resource "aws_lb_target_group" "alb-example" { } ``` +### Target group with unhealthy connection termination disabled + +```terraform +resource "aws_lb_target_group" "tcp-example" { + name = "tf-example-lb-nlb-tg" + port = 25 + protocol = "TCP" + vpc_id = aws_vpc.main.id + + target_health_state { + enable_unhealthy_connection_termination = false + } +} +``` + ## Argument Reference This resource supports the following arguments: @@ -87,6 +102,7 @@ This resource supports the following arguments: * `stickiness` - (Optional, Maximum of 1) Stickiness configuration block. Detailed below. * `tags` - (Optional) Map of tags to assign to the resource. If configured with a provider [`default_tags` configuration block](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#default_tags-configuration-block) present, tags with matching keys will overwrite those defined at the provider-level. * `target_failover` - (Optional) Target failover block. Only applicable for Gateway Load Balancer target groups. See [target_failover](#target_failover) for more information. +* `target_health_state` - (Optional) Target health state block. Only applicable for Network Load Balancer target groups when `protocol` is `TCP` or `TLS`. See [target_health_state](#target_health_state) for more information. * `target_type` - (May be required, Forces new resource) Type of target that you must specify when registering targets with this target group. See [doc](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_CreateTargetGroup.html) 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. @@ -129,6 +145,12 @@ This resource supports the following arguments: * `on_deregistration` - (Optional) Indicates how the GWLB handles existing flows when a target is deregistered. Possible values are `rebalance` and `no_rebalance`. Must match the attribute value set for `on_unhealthy`. Default: `no_rebalance`. * `on_unhealthy` - Indicates how the GWLB handles existing flows when a target is unhealthy. Possible values are `rebalance` and `no_rebalance`. Must match the attribute value set for `on_deregistration`. Default: `no_rebalance`. +### target_health_state + +~> **NOTE:** This block is only valid for a Network Load Balancer (NLB) target group when `protocol` is `TCP` or `TLS`. + +* `enable_unhealthy_connection_termination` - (Optional) Indicates whether the load balancer terminates connections to unhealthy targets. Possible values are `true` or `false`. Default: `true`. + ## Attribute Reference This resource exports the following attributes in addition to the arguments above: From 5fbb592e6553eb27ac8df92ff1dc069661b2af19 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 24 Oct 2023 08:12:55 -0400 Subject: [PATCH 8/8] Tweak CHANGELOG entries. --- .changelog/34070.txt | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.changelog/34070.txt b/.changelog/34070.txt index 72ee32e66db..d95439d5778 100644 --- a/.changelog/34070.txt +++ b/.changelog/34070.txt @@ -1,4 +1,7 @@ ```release-note:enhancement -resource/aws_lb_target_group: Add `target_health_state` block with attribute `enable_unhealthy_connection_termination` to disabling connection termination for unhealthy targets on NLB -resource/aws_lb_target_group: Removes the default `false` value for the `connection_termination` attribute to support new default behavior for UDP/TCP_UDP target groups -``` \ No newline at end of file +resource/aws_lb_target_group: Add `target_health_state` configuration block +``` + +```release-note:enhancement +resource/aws_lb_target_group: Remove default value (`false`) for `connection_termination` argument and mark as Computed, to support new default behavior for UDP/TCP_UDP target groups +```