Address PR comments.

Author: Ryan Lymburner

docs/api-types/target-group-policy.md

@@ -94,7 +94,7 @@ spec:
         path: "/health"
         port: 8080
         protocol: HTTP
-        protocolVersion: HTTP1
+        protocolVersion: HTTP2
         statusMatch: "200-299"
 ```
 

docs/guides/advanced-configurations.md

@@ -48,10 +48,6 @@ The `{index}` in the annotation corresponds to the zero-based index of the rule
 
 Higher priority values indicate higher precedence, so requests to `/api/v2` will be matched by the first rule (priority 200) before the second rule (priority 100) is considered.
 
-### Multi-Cluster Health Check Configuration
-
-In multi-cluster deployments, you can ensure consistent health check configuration across all clusters by applying TargetGroupPolicy to ServiceExport resources. This eliminates the previous limitation where only the cluster containing the route resource would receive the correct health check configuration.
-
 #### Configuring Health Checks for ServiceExport
 
 When you apply a TargetGroupPolicy to a ServiceExport, the health check configuration is automatically propagated to all target groups across all clusters that participate in the service mesh:

pkg/deploy/lattice/health_check_resolver.go

@@ -41,7 +41,7 @@ func NewHealthCheckConfigResolver(log gwlog.Logger, client client.Client) *Healt
 // 5. Preserves existing behavior when no policies are applicable
 func (r *HealthCheckConfigResolver) ResolveHealthCheckConfig(ctx context.Context, targetGroup *model.TargetGroup) (*vpclattice.HealthCheckConfig, error) {
 	if r.client == nil {
-		r.log.Debugf(ctx, "No client available for policy resolution, skipping health check config resolution")
+		r.log.Debugf(ctx, "No k8sClient available for policy resolution, skipping health check config resolution")
 		return nil, nil
 	}
 

pkg/deploy/lattice/health_check_resolver_test.go

@@ -78,7 +78,7 @@ func TestHealthCheckConfigResolver_ResolveHealthCheckConfig(t *testing.T) {
 			_ = anv1alpha1.Install(scheme)
 			_ = corev1.AddToScheme(scheme)
 
-			// Create fake client with no objects
+			// Create fake k8sClient with no objects
 			k8sClient := fake.NewClientBuilder().
 				WithScheme(scheme).
 				Build()
@@ -438,14 +438,14 @@ func Test_ResolveHealthCheckConfig_WithPolicies(t *testing.T) {
 			_ = corev1.AddToScheme(scheme)
 			_ = gwv1alpha2.Install(scheme)
 
-			// Convert policies to client.Object slice
+			// Convert policies to k8sClient.Object slice
 			objects := make([]client.Object, len(tt.policies))
 			for i, policy := range tt.policies {
 				policyCopy := policy
 				objects[i] = &policyCopy
 			}
 
-			// Create fake client with policies
+			// Create fake k8sClient with policies
 			k8sClient := fake.NewClientBuilder().
 				WithScheme(scheme).
 				WithObjects(objects...).
@@ -492,7 +492,7 @@ func Test_ResolveHealthCheckConfig_ErrorHandling(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			ctx := context.Background()
 
-			// Create a mock controller and client that returns an error
+			// Create a mock controller and k8sClient that returns an error
 			c := gomock.NewController(t)
 			defer c.Finish()
 

pkg/deploy/lattice/target_group_manager.go

@@ -32,16 +32,16 @@ type TargetGroupManager interface {
 }
 
 type defaultTargetGroupManager struct {
-	log    gwlog.Logger
-	cloud  pkg_aws.Cloud
-	client client.Client
+	log       gwlog.Logger
+	awsCloud  pkg_aws.Cloud
+	k8sClient client.Client
 }
 
-func NewTargetGroupManager(log gwlog.Logger, cloud pkg_aws.Cloud, client client.Client) *defaultTargetGroupManager {
+func NewTargetGroupManager(log gwlog.Logger, awsCloud pkg_aws.Cloud, k8sClient client.Client) *defaultTargetGroupManager {
 	return &defaultTargetGroupManager{
-		log:    log,
-		cloud:  cloud,
-		client: client,
+		log:       log,
+		awsCloud:  awsCloud,
+		k8sClient: k8sClient,
 	}
 }
 
@@ -89,7 +89,7 @@ func (s *defaultTargetGroupManager) create(ctx context.Context, modelTg *model.T
 		Config: latticeTgCfg,
 		Name:   &latticeTgName,
 		Type:   &latticeTgType,
-		Tags:   s.cloud.DefaultTags(),
+		Tags:   s.awsCloud.DefaultTags(),
 	}
 	createInput.Tags[model.K8SClusterNameKey] = &modelTg.Spec.K8SClusterName
 	createInput.Tags[model.K8SServiceNameKey] = &modelTg.Spec.K8SServiceName
@@ -102,7 +102,7 @@ func (s *defaultTargetGroupManager) create(ctx context.Context, modelTg *model.T
 		createInput.Tags[model.K8SRouteNamespaceKey] = &modelTg.Spec.K8SRouteNamespace
 	}
 
-	lattice := s.cloud.Lattice()
+	lattice := s.awsCloud.Lattice()
 	resp, err := lattice.CreateTargetGroupWithContext(ctx, &createInput)
 	if err != nil {
 		return model.TargetGroupStatus{},
@@ -135,7 +135,7 @@ func (s *defaultTargetGroupManager) update(ctx context.Context, targetGroup *mod
 	}
 
 	// Try to resolve health check configuration from TargetGroupPolicy using centralized resolver
-	resolver := NewHealthCheckConfigResolver(s.log, s.client)
+	resolver := NewHealthCheckConfigResolver(s.log, s.k8sClient)
 	policyHealthCheckConfig, err := resolver.ResolveHealthCheckConfig(ctx, targetGroup)
 	if err != nil {
 		s.log.Debugf(ctx, "Failed to resolve health check config from policy: %v", err)
@@ -148,7 +148,7 @@ func (s *defaultTargetGroupManager) update(ctx context.Context, targetGroup *mod
 	s.fillDefaultHealthCheckConfig(healthCheckConfig, targetGroup.Spec.Protocol, targetGroup.Spec.ProtocolVersion)
 
 	if !reflect.DeepEqual(healthCheckConfig, latticeTg.Config.HealthCheck) {
-		_, err := s.cloud.Lattice().UpdateTargetGroupWithContext(ctx, &vpclattice.UpdateTargetGroupInput{
+		_, err := s.awsCloud.Lattice().UpdateTargetGroupWithContext(ctx, &vpclattice.UpdateTargetGroupInput{
 			HealthCheck:           healthCheckConfig,
 			TargetGroupIdentifier: latticeTg.Id,
 		})
@@ -188,7 +188,7 @@ func (s *defaultTargetGroupManager) Delete(ctx context.Context, modelTg *model.T
 	}
 	s.log.Debugf(ctx, "Deleting target group %s", modelTg.Status.Id)
 
-	lattice := s.cloud.Lattice()
+	lattice := s.awsCloud.Lattice()
 
 	// de-register all targets first
 	listTargetsInput := vpclattice.ListTargetsInput{
@@ -269,7 +269,7 @@ type tgListOutput struct {
 
 // Retrieve all TGs in the account, including tags. If individual tags fetch fails, tags will be nil for that tg
 func (s *defaultTargetGroupManager) List(ctx context.Context) ([]tgListOutput, error) {
-	lattice := s.cloud.Lattice()
+	lattice := s.awsCloud.Lattice()
 	var tgList []tgListOutput
 	targetGroupListInput := vpclattice.ListTargetGroupsInput{}
 	resp, err := lattice.ListTargetGroupsAsList(ctx, &targetGroupListInput)
@@ -282,7 +282,7 @@ func (s *defaultTargetGroupManager) List(ctx context.Context) ([]tgListOutput, e
 	tgArns := utils.SliceMap(resp, func(tg *vpclattice.TargetGroupSummary) string {
 		return aws.StringValue(tg.Arn)
 	})
-	tgArnToTagsMap, err := s.cloud.Tagging().GetTagsForArns(ctx, tgArns)
+	tgArnToTagsMap, err := s.awsCloud.Tagging().GetTagsForArns(ctx, tgArns)
 
 	if err != nil {
 		return nil, err
@@ -300,7 +300,7 @@ func (s *defaultTargetGroupManager) findTargetGroup(
 	ctx context.Context,
 	modelTargetGroup *model.TargetGroup,
 ) (*vpclattice.GetTargetGroupOutput, error) {
-	arns, err := s.cloud.Tagging().FindResourcesByTags(ctx, services.ResourceTypeTargetGroup,
+	arns, err := s.awsCloud.Tagging().FindResourcesByTags(ctx, services.ResourceTypeTargetGroup,
 		model.TagsFromTGTagFields(modelTargetGroup.Spec.TargetGroupTagFields))
 	if err != nil {
 		return nil, err
@@ -310,7 +310,7 @@ func (s *defaultTargetGroupManager) findTargetGroup(
 	}
 
 	for _, arn := range arns {
-		latticeTg, err := s.cloud.Lattice().GetTargetGroupWithContext(ctx, &vpclattice.GetTargetGroupInput{
+		latticeTg, err := s.awsCloud.Lattice().GetTargetGroupWithContext(ctx, &vpclattice.GetTargetGroupInput{
 			TargetGroupIdentifier: &arn,
 		})
 		if err != nil {

pkg/deploy/lattice/target_group_manager_test.go

@@ -1215,8 +1215,8 @@ func Test_update_ServiceExportWithPolicy_Integration(t *testing.T) {
 	mockTagging := mocks.NewMockTagging(c)
 	cloud := pkg_aws.NewDefaultCloudWithTagging(mockLattice, mockTagging, TestCloudConfig)
 
-	// Since we don't have a real k8s client in this test, we'll test the case where
-	// no client is available (which should fall back to default behavior)
+	// Since we don't have a real k8s k8sClient in this test, we'll test the case where
+	// no k8sClient is available (which should fall back to default behavior)
 	tgManager := NewTargetGroupManager(gwlog.FallbackLogger, cloud, nil)
 
 	// The update should not call UpdateTargetGroup since the health check config
@@ -1411,7 +1411,7 @@ func Test_update_ServiceExportWithPolicyResolution(t *testing.T) {
 			_ = corev1.AddToScheme(scheme)
 			_ = gwv1alpha2.Install(scheme)
 
-			// Create fake client with policy if provided
+			// Create fake k8sClient with policy if provided
 			clientBuilder := fake.NewClientBuilder().WithScheme(scheme)
 			if tt.policy != nil {
 				clientBuilder = clientBuilder.WithObjects(tt.policy)
@@ -1451,18 +1451,18 @@ func Test_update_ServiceExportWithPolicyResolution(t *testing.T) {
 }
 
 // Test_update_BackwardsCompatibility tests that existing behavior is preserved
-// when no policies are present or when the client is nil
+// when no policies are present or when the k8sClient is nil
 func Test_update_BackwardsCompatibility(t *testing.T) {
 	tests := []struct {
 		name                string
-		client              bool // whether to provide a k8s client
+		client              bool // whether to provide a k8s k8sClient
 		targetGroup         *model.TargetGroup
 		existingHealthCheck *vpclattice.HealthCheckConfig
 		expectedHealthCheck *vpclattice.HealthCheckConfig
 		expectUpdate        bool
 	}{
 		{
-			name:   "No client provided - should use default behavior",
+			name:   "No k8sClient provided - should use default behavior",
 			client: false,
 			targetGroup: &model.TargetGroup{
 				Spec: model.TargetGroupSpec{
@@ -1538,7 +1538,7 @@ func Test_update_BackwardsCompatibility(t *testing.T) {
 			expectUpdate: false, // Same config, no update needed
 		},
 		{
-			name:   "HTTPRoute target group with client - should skip policy resolution",
+			name:   "HTTPRoute target group with k8sClient - should skip policy resolution",
 			client: true,
 			targetGroup: &model.TargetGroup{
 				Spec: model.TargetGroupSpec{

pkg/deploy/lattice/target_group_synthesizer_test.go

@@ -515,11 +515,11 @@ func Test_SynthesizeCreate_WithServiceExportTargetGroup(t *testing.T) {
 	mockTGManager.EXPECT().Upsert(ctx, gomock.Any()).Return(
 		model.TargetGroupStatus{Name: "test-tg", Arn: "arn:test", Id: "tg-123"}, nil)
 
-	// Create the synthesizer with nil client to test graceful handling when no client is available
+	// Create the synthesizer with nil k8sClient to test graceful handling when no k8sClient is available
 	synthesizer := NewTargetGroupSynthesizer(
 		gwlog.FallbackLogger, nil, nil, mockTGManager, nil, nil, stack)
 
-	// Execute SynthesizeCreate - should not fail even when client is nil
+	// Execute SynthesizeCreate - should not fail even when k8sClient is nil
 	err = synthesizer.SynthesizeCreate(ctx)
 	assert.NoError(t, err)
 }