feat(bedrock): Add support for Agent Alias and Flow Alias (ekristen#664)

* feat(bedrock-agent-alias): add BedrockAgentAlias module

* feat(bedrock-flow-alias): add BedrockFlowAlias module

* fix(bedrock-agent-alias): adding Resource to BedrockAgentAlias registration

* fix(bedrock-agent-alias): switching pointer reference to "r"

* feat(bedrock-agent-alias): adding dependency on BedrockAgent

* fix(bedrock-flow-alias): adding Resource to BedrockFlowAlias registration

* refactor(bedrock-flow-alias): switching pointer ref and moved utility function

* refactor(bedrock-agent-alias): move utility function to end of file

* fix: linting adjustments

* fix: linting adjustments

Author: sstoops

resources/bedrock-agent-alias.go

@@ -0,0 +1,117 @@
+package resources
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/bedrockagent"
+
+	"github.com/ekristen/libnuke/pkg/registry"
+	"github.com/ekristen/libnuke/pkg/resource"
+	"github.com/ekristen/libnuke/pkg/types"
+
+	"github.com/ekristen/aws-nuke/v3/pkg/nuke"
+)
+
+const BedrockAgentAliasResource = "BedrockAgentAlias"
+
+func init() {
+	registry.Register(&registry.Registration{
+		Name:     BedrockAgentAliasResource,
+		Scope:    nuke.Account,
+		Lister:   &BedrockAgentAliasLister{},
+		Resource: &BedrockAgentAlias{},
+		DependsOn: []string{
+			BedrockAgentResource,
+		},
+	})
+}
+
+type BedrockAgentAliasLister struct{}
+
+func (l *BedrockAgentAliasLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) {
+	opts := o.(*nuke.ListerOpts)
+
+	svc := bedrockagent.New(opts.Session)
+	resources := make([]resource.Resource, 0)
+
+	agentIDs, err := ListBedrockAgentIds(svc)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, agentID := range agentIDs {
+		params := &bedrockagent.ListAgentAliasesInput{
+			MaxResults: aws.Int64(100),
+			AgentId:    aws.String(agentID),
+		}
+		for {
+			output, err := svc.ListAgentAliases(params)
+			if err != nil {
+				return nil, err
+			}
+
+			for _, agentAliasInfo := range output.AgentAliasSummaries {
+				resources = append(resources, &BedrockAgentAlias{
+					svc:            svc,
+					AgentID:        aws.String(agentID),
+					AgentAliasName: agentAliasInfo.AgentAliasName,
+					AgentAliasID:   agentAliasInfo.AgentAliasId,
+				})
+			}
+
+			if output.NextToken == nil {
+				break
+			}
+			params.NextToken = output.NextToken
+		}
+	}
+	return resources, nil
+}
+
+type BedrockAgentAlias struct {
+	svc            *bedrockagent.BedrockAgent
+	AgentID        *string
+	AgentAliasID   *string
+	AgentAliasName *string
+}
+
+func (r *BedrockAgentAlias) Properties() types.Properties {
+	return types.NewPropertiesFromStruct(r)
+}
+
+func (r *BedrockAgentAlias) Remove(_ context.Context) error {
+	_, err := r.svc.DeleteAgentAlias(&bedrockagent.DeleteAgentAliasInput{
+		AgentAliasId: r.AgentAliasID,
+		AgentId:      r.AgentID,
+	})
+	return err
+}
+
+func (r *BedrockAgentAlias) String() string {
+	return *r.AgentAliasName
+}
+
+func ListBedrockAgentIds(svc *bedrockagent.BedrockAgent) ([]string, error) {
+	agentIds := []string{}
+	params := &bedrockagent.ListAgentsInput{
+		MaxResults: aws.Int64(100),
+	}
+	for {
+		output, err := svc.ListAgents(params)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, agent := range output.AgentSummaries {
+			agentIds = append(agentIds, *agent.AgentId)
+		}
+
+		if output.NextToken == nil {
+			break
+		}
+		params.NextToken = output.NextToken
+	}
+
+	return agentIds, nil
+}

resources/bedrock-flow-alias.go

@@ -0,0 +1,123 @@
+package resources
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/bedrockagent"
+
+	"github.com/ekristen/libnuke/pkg/registry"
+	"github.com/ekristen/libnuke/pkg/resource"
+	"github.com/ekristen/libnuke/pkg/types"
+
+	"github.com/ekristen/aws-nuke/v3/pkg/nuke"
+)
+
+const BedrockFlowAliasResource = "BedrockFlowAlias"
+
+func init() {
+	registry.Register(&registry.Registration{
+		Name:     BedrockFlowAliasResource,
+		Scope:    nuke.Account,
+		Lister:   &BedrockFlowAliasLister{},
+		Resource: &BedrockFlowAlias{},
+	})
+}
+
+type BedrockFlowAliasLister struct{}
+
+func (l *BedrockFlowAliasLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) {
+	opts := o.(*nuke.ListerOpts)
+
+	svc := bedrockagent.New(opts.Session)
+	resources := make([]resource.Resource, 0)
+
+	flowIDs, err := ListBedrockFlowIds(svc)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, flowID := range flowIDs {
+		params := &bedrockagent.ListFlowAliasesInput{
+			MaxResults:     aws.Int64(100),
+			FlowIdentifier: aws.String(flowID),
+		}
+		for {
+			output, err := svc.ListFlowAliases(params)
+			if err != nil {
+				return nil, err
+			}
+
+			for _, flowAliasInfo := range output.FlowAliasSummaries {
+				resources = append(resources, &BedrockFlowAlias{
+					svc:           svc,
+					FlowID:        flowAliasInfo.FlowId,
+					FlowAliasID:   flowAliasInfo.Id,
+					FlowAliasName: flowAliasInfo.Name,
+				})
+			}
+
+			if output.NextToken == nil {
+				break
+			}
+			params.NextToken = output.NextToken
+		}
+	}
+	return resources, nil
+}
+
+type BedrockFlowAlias struct {
+	svc           *bedrockagent.BedrockAgent
+	FlowID        *string
+	FlowAliasID   *string
+	FlowAliasName *string
+}
+
+func (r *BedrockFlowAlias) Filter() error {
+	if strings.HasPrefix(*r.FlowAliasName, "TSTALIASID") {
+		return fmt.Errorf("cannot delete AWS managed Flow Alias")
+	}
+	return nil
+}
+
+func (r *BedrockFlowAlias) Properties() types.Properties {
+	return types.NewPropertiesFromStruct(r)
+}
+
+func (r *BedrockFlowAlias) Remove(_ context.Context) error {
+	_, err := r.svc.DeleteFlowAlias(&bedrockagent.DeleteFlowAliasInput{
+		AliasIdentifier: r.FlowAliasID,
+		FlowIdentifier:  r.FlowID,
+	})
+	return err
+}
+
+func (r *BedrockFlowAlias) String() string {
+	return *r.FlowAliasName
+}
+
+func ListBedrockFlowIds(svc *bedrockagent.BedrockAgent) ([]string, error) {
+	flowIds := []string{}
+	params := &bedrockagent.ListFlowsInput{
+		MaxResults: aws.Int64(100),
+	}
+	for {
+		output, err := svc.ListFlows(params)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, flow := range output.FlowSummaries {
+			flowIds = append(flowIds, *flow.Id)
+		}
+
+		if output.NextToken == nil {
+			break
+		}
+		params.NextToken = output.NextToken
+	}
+
+	return flowIds, nil
+}