Repository: gruntwork-io/cloud-nuke
Pull request #781 (2024-11-09 06:44:28)

change port ec2 dedicated host, ec2 dhcp option, ec2 endpoints, ec2 key pair ... to awsSDKv2 #770
## Description

change port resources to aws SDK v2

- ec2 dedicated host
- ec2 dhcp option
- ec2 endpoints
- ec2 key pair
- ec2 placement group
- kinesis firehose
- kinesis stream
- kms customer key
- lambda layer
- lambda
- macie

## TODOs

Read the [Gruntwork contribution guidelines](https://gruntwork.notion.site/Gruntwork-Coding-Methodology-02fdcd6e4b004e818553684760bf691e).

- [x] Update the docs.
- [x] Run the relevant tests successfully, including pre-commit checks.
- [x] Ensure any 3rd party code adheres with our [license policy](https://www.notion.so/gruntwork/Gruntwork-licenses-and-open-source-usage-policy-f7dece1f780341c7b69c1763f22b1378) or delete this line if its not applicable.
- [x] Include release notes. If this PR is backward incompatible, include a migration guide.
- [ ] Attention Grunts - if this PR adds support for a new resource, ensure the `nuke_sandbox` and `nuke_phxdevops` jobs in `.circleci/config.yml` have been updated with appropriate exclusions (either directly in the job or via the `.circleci/nuke_config.yml` file) to prevent nuking IAM roles, groups, resources, etc that are important for the test accounts.


## Release Notes (draft)

[x] Updated ec2 dedicated host, ec2 dhcp option, ec2 endpoints, ec2 key pair, ec2 placement group, kinesis firehose, kinesis stream, kms customer key, lambda layer, lambda, macie resources to awsSDKv2

### Migration Guide

n/a



Patch:
diff --git a/aws/resources/ec2_dedicated_host.go b/aws/resources/ec2_dedicated_host.go
index 3dbb436..27d2d60 100644
--- a/aws/resources/ec2_dedicated_host.go
+++ b/aws/resources/ec2_dedicated_host.go
@@ -4,9 +4,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -16,41 +16,37 @@ import (
 
 func (h *EC2DedicatedHosts) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var hostIds []*string
-
 	describeHostsInput := &ec2.DescribeHostsInput{
-		Filter: []*ec2.Filter{
+		Filter: []types.Filter{
 			{
-				Name: awsgo.String("state"),
-				Values: []*string{
-					awsgo.String("available"),
-					awsgo.String("under-assessment"),
-					awsgo.String("permanent-failure"),
+				Name: aws.String("state"),
+				Values: []string{
+					"available",
+					"under-assessment",
+					"permanent-failure",
 				},
 			},
 		},
 	}
 
-	err := h.Client.DescribeHostsPagesWithContext(
-		h.Context,
-		describeHostsInput,
-		func(page *ec2.DescribeHostsOutput, lastPage bool) bool {
-			for _, host := range page.Hosts {
-				if shouldIncludeHostId(host, configObj) {
-					hostIds = append(hostIds, host.HostId)
-				}
-			}
-			return !lastPage
-		},
-	)
+	paginator := ec2.NewDescribeHostsPaginator(h.Client, describeHostsInput)
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
 
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
+		for _, host := range page.Hosts {
+			if shouldIncludeHostId(&host, configObj) {
+				hostIds = append(hostIds, host.HostId)
+			}
+		}
 	}
 
 	return hostIds, nil
 }
 
-func shouldIncludeHostId(host *ec2.Host, configObj config.Config) bool {
+func shouldIncludeHostId(host *types.Host, configObj config.Config) bool {
 	if host == nil {
 		return false
 	}
@@ -79,9 +75,9 @@ func (h *EC2DedicatedHosts) nukeAll(hostIds []*string) error {
 
 	logging.Debugf("Releasing all EC2 dedicated host allocations in region %s", h.Region)
 
-	input := &ec2.ReleaseHostsInput{HostIds: hostIds}
+	input := &ec2.ReleaseHostsInput{HostIds: aws.ToStringSlice(hostIds)}
 
-	releaseResult, err := h.Client.ReleaseHostsWithContext(h.Context, input)
+	releaseResult, err := h.Client.ReleaseHosts(h.Context, input)
 
 	if err != nil {
 		logging.Debugf("[Failed] %s", err)
@@ -90,18 +86,18 @@ func (h *EC2DedicatedHosts) nukeAll(hostIds []*string) error {
 
 	// Report successes and failures from release host request
 	for _, hostSuccess := range releaseResult.Successful {
-		logging.Debugf("[OK] Dedicated host %s was released in %s", aws.StringValue(hostSuccess), h.Region)
+		logging.Debugf("[OK] Dedicated host %s was released in %s", hostSuccess, h.Region)
 		e := report.Entry{
-			Identifier:   aws.StringValue(hostSuccess),
+			Identifier:   hostSuccess,
 			ResourceType: "EC2 Dedicated Host",
 		}
 		report.Record(e)
 	}
 
 	for _, hostFailed := range releaseResult.Unsuccessful {
-		logging.Debugf("[ERROR] Unable to release dedicated host %s in %s: %s", aws.StringValue(hostFailed.ResourceId), h.Region, aws.StringValue(hostFailed.Error.Message))
+		logging.Debugf("[ERROR] Unable to release dedicated host %s in %s: %s", aws.ToString(hostFailed.ResourceId), h.Region, aws.ToString(hostFailed.Error.Message))
 		e := report.Entry{
-			Identifier:   aws.StringValue(hostFailed.ResourceId),
+			Identifier:   aws.ToString(hostFailed.ResourceId),
 			ResourceType: "EC2 Dedicated Host",
 			Error:        fmt.Errorf(*hostFailed.Error.Message),
 		}
diff --git a/aws/resources/ec2_dedicated_host_types.go b/aws/resources/ec2_dedicated_host_types.go
index 7dd58ff..0774836 100644
--- a/aws/resources/ec2_dedicated_host_types.go
+++ b/aws/resources/ec2_dedicated_host_types.go
@@ -3,26 +3,31 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type EC2DedicatedHostsAPI interface {
+	DescribeHosts(ctx context.Context, params *ec2.DescribeHostsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeHostsOutput, error)
+	ReleaseHosts(ctx context.Context, params *ec2.ReleaseHostsInput, optFns ...func(*ec2.Options)) (*ec2.ReleaseHostsOutput, error)
+}
+
 // EC2DedicatedHosts - represents all host allocation IDs
 type EC2DedicatedHosts struct {
 	BaseAwsResource
-	Client  ec2iface.EC2API
+	Client  EC2DedicatedHostsAPI
 	Region  string
 	HostIds []string
 }
 
-func (h *EC2DedicatedHosts) Init(session *session.Session) {
-	h.Client = ec2.New(session)
+func (h *EC2DedicatedHosts) InitV2(cfg aws.Config) {
+	h.Client = ec2.NewFromConfig(cfg)
 }
 
+func (h *EC2DedicatedHosts) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (h *EC2DedicatedHosts) ResourceName() string {
 	return "ec2-dedicated-hosts"
@@ -48,13 +53,13 @@ func (h *EC2DedicatedHosts) GetAndSetIdentifiers(c context.Context, configObj co
 		return nil, err
 	}
 
-	h.HostIds = awsgo.StringValueSlice(identifiers)
+	h.HostIds = aws.ToStringSlice(identifiers)
 	return h.HostIds, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (h *EC2DedicatedHosts) Nuke(identifiers []string) error {
-	if err := h.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := h.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/ec2_dhcp_option.go b/aws/resources/ec2_dhcp_option.go
index 5aa9d58..e85ad79 100644
--- a/aws/resources/ec2_dhcp_option.go
+++ b/aws/resources/ec2_dhcp_option.go
@@ -3,9 +3,9 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -13,19 +13,26 @@ import (
 	"github.com/pterm/pterm"
 )
 
-func (v *EC2DhcpOption) getAll(_ context.Context, configObj config.Config) ([]*string, error) {
+func (v *EC2DhcpOption) getAll(ctx context.Context, configObj config.Config) ([]*string, error) {
 	var dhcpOptionIds []*string
-	err := v.Client.DescribeDhcpOptionsPagesWithContext(v.Context, &ec2.DescribeDhcpOptionsInput{}, func(page *ec2.DescribeDhcpOptionsOutput, lastPage bool) bool {
+
+	paginator := ec2.NewDescribeDhcpOptionsPaginator(v.Client, &ec2.DescribeDhcpOptionsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(ctx)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
 		for _, dhcpOption := range page.DhcpOptions {
 			var isEligibleForNuke = true
 
 			// check the dhcp is attached with any vpc
 			// if the vpc is default one, then omit the dhcp option id from result
-			vpcs, err := v.Client.DescribeVpcsWithContext(v.Context, &ec2.DescribeVpcsInput{
-				Filters: []*ec2.Filter{
+			vpcs, err := v.Client.DescribeVpcs(v.Context, &ec2.DescribeVpcsInput{
+				Filters: []types.Filter{
 					{
-						Name:   awsgo.String("dhcp-options-id"),
-						Values: []*string{dhcpOption.DhcpOptionsId},
+						Name:   aws.String("dhcp-options-id"),
+						Values: []string{aws.ToString(dhcpOption.DhcpOptionsId)},
 					},
 				},
 			})
@@ -36,12 +43,12 @@ func (v *EC2DhcpOption) getAll(_ context.Context, configObj config.Config) ([]*s
 
 			for _, vpc := range vpcs.Vpcs {
 				// check the vpc is the default one then set isEligible false as we dont need to remove the dhcp option of default vpc
-				if awsgo.BoolValue(vpc.IsDefault) {
-					logging.Debugf("[Skipping] %s is attached with a default vpc %s", awsgo.StringValue(dhcpOption.DhcpOptionsId), awsgo.StringValue(vpc.VpcId))
+				if aws.ToBool(vpc.IsDefault) {
+					logging.Debugf("[Skipping] %s is attached with a default vpc %s", aws.ToString(dhcpOption.DhcpOptionsId), aws.ToString(vpc.VpcId))
 					isEligibleForNuke = false
 				}
 
-				v.DhcpOptions[awsgo.StringValue(dhcpOption.DhcpOptionsId)] = DHCPOption{
+				v.DhcpOptions[aws.ToString(dhcpOption.DhcpOptionsId)] = DHCPOption{
 					Id:    dhcpOption.DhcpOptionsId,
 					VpcId: vpc.VpcId,
 				}
@@ -53,22 +60,15 @@ func (v *EC2DhcpOption) getAll(_ context.Context, configObj config.Config) ([]*s
 				// filtering with name tag in the future. In the initial version, we just getAll
 				// without filtering.
 				dhcpOptionIds = append(dhcpOptionIds, dhcpOption.DhcpOptionsId)
-
 			}
 		}
-
-		return !lastPage
-	})
-
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
 	}
 
 	// checking the nukable permissions
 	v.VerifyNukablePermissions(dhcpOptionIds, func(id *string) error {
-		_, err := v.Client.DeleteDhcpOptionsWithContext(v.Context, &ec2.DeleteDhcpOptionsInput{
+		_, err := v.Client.DeleteDhcpOptions(v.Context, &ec2.DeleteDhcpOptionsInput{
 			DhcpOptionsId: id,
-			DryRun:        awsgo.Bool(true),
+			DryRun:        aws.Bool(true),
 		})
 		return err
 	})
@@ -77,18 +77,18 @@ func (v *EC2DhcpOption) getAll(_ context.Context, configObj config.Config) ([]*s
 }
 
 func (v *EC2DhcpOption) disAssociatedAttachedVpcs(identifier *string) error {
-	if option, ok := v.DhcpOptions[awsgo.StringValue(identifier)]; ok {
-		logging.Debugf("[disAssociatedAttachedVpcs] detaching the dhcp option %s from %v", awsgo.StringValue(identifier), awsgo.StringValue(option.VpcId))
+	if option, ok := v.DhcpOptions[aws.ToString(identifier)]; ok {
+		logging.Debugf("[disAssociatedAttachedVpcs] detaching the dhcp option %s from %v", aws.ToString(identifier), aws.ToString(option.VpcId))
 
-		_, err := v.Client.AssociateDhcpOptionsWithContext(v.Context, &ec2.AssociateDhcpOptionsInput{
+		_, err := v.Client.AssociateDhcpOptions(v.Context, &ec2.AssociateDhcpOptionsInput{
 			VpcId:         option.VpcId,
-			DhcpOptionsId: awsgo.String("default"), // The ID of the DHCP options set, or default to associate no DHCP options with the VPC.
+			DhcpOptionsId: aws.String("default"), // The ID of the DHCP options set, or default to associate no DHCP options with the VPC.
 		})
 		if err != nil {
 			logging.Debugf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
-		logging.Debugf("[disAssociatedAttachedVpcs] Success dhcp option %s detached from %v", awsgo.StringValue(identifier), awsgo.StringValue(option.VpcId))
+		logging.Debugf("[disAssociatedAttachedVpcs] Success dhcp option %s detached from %v", aws.ToString(identifier), aws.ToString(option.VpcId))
 	}
 
 	return nil
@@ -102,7 +102,7 @@ func (v *EC2DhcpOption) nuke(identifier *string) error {
 		return errors.WithStackTrace(err)
 	}
 
-	err = nukeDhcpOption(v.Client, identifier)
+	err = nukeDhcpOption(v.Context, v.Client, identifier)
 	if err != nil {
 		logging.Debugf("[nukeDhcpOption] Failed %s", err)
 		return errors.WithStackTrace(err)
@@ -112,8 +112,8 @@ func (v *EC2DhcpOption) nuke(identifier *string) error {
 
 func (v *EC2DhcpOption) nukeAll(identifiers []*string) error {
 	for _, identifier := range identifiers {
-		if nukable, reason := v.IsNukable(awsgo.StringValue(identifier)); !nukable {
-			logging.Debugf("[Skipping] %s nuke because %v", awsgo.StringValue(identifier), reason)
+		if nukable, reason := v.IsNukable(aws.ToString(identifier)); !nukable {
+			logging.Debugf("[Skipping] %s nuke because %v", aws.ToString(identifier), reason)
 			continue
 		}
 
@@ -126,7 +126,7 @@ func (v *EC2DhcpOption) nukeAll(identifiers []*string) error {
 
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   awsgo.StringValue(identifier),
+			Identifier:   aws.ToString(identifier),
 			ResourceType: v.ResourceName(),
 			Error:        err,
 		}
@@ -136,16 +136,16 @@ func (v *EC2DhcpOption) nukeAll(identifiers []*string) error {
 	return nil
 }
 
-func nukeDhcpOption(client ec2iface.EC2API, option *string) error {
-	logging.Debugf("Deleting DHCP Option %s", awsgo.StringValue(option))
+func nukeDhcpOption(ctx context.Context, client EC2DhcpOptionAPI, option *string) error {
+	logging.Debugf("Deleting DHCP Option %s", aws.ToString(option))
 
-	_, err := client.DeleteDhcpOptions(&ec2.DeleteDhcpOptionsInput{
+	_, err := client.DeleteDhcpOptions(ctx, &ec2.DeleteDhcpOptionsInput{
 		DhcpOptionsId: option,
 	})
 	if err != nil {
-		logging.Debugf("[Failed] Error deleting DHCP option %s: %s", awsgo.StringValue(option), err)
+		logging.Debugf("[Failed] Error deleting DHCP option %s: %s", aws.ToString(option), err)
 		return errors.WithStackTrace(err)
 	}
-	logging.Debugf("[Ok] DHCP Option deleted successfully %s", awsgo.StringValue(option))
+	logging.Debugf("[Ok] DHCP Option deleted successfully %s", aws.ToString(option))
 	return nil
 }
diff --git a/aws/resources/ec2_dhcp_option_types.go b/aws/resources/ec2_dhcp_option_types.go
index 7735f3c..e19aac4 100644
--- a/aws/resources/ec2_dhcp_option_types.go
+++ b/aws/resources/ec2_dhcp_option_types.go
@@ -3,10 +3,8 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
@@ -16,19 +14,28 @@ type DHCPOption struct {
 	VpcId *string
 }
 
+type EC2DhcpOptionAPI interface {
+	AssociateDhcpOptions(ctx context.Context, params *ec2.AssociateDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.AssociateDhcpOptionsOutput, error)
+	DescribeDhcpOptions(ctx context.Context, params *ec2.DescribeDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error)
+	DescribeVpcs(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error)
+	DeleteDhcpOptions(ctx context.Context, params *ec2.DeleteDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteDhcpOptionsOutput, error)
+}
+
 type EC2DhcpOption struct {
 	BaseAwsResource
-	Client      ec2iface.EC2API
+	Client      EC2DhcpOptionAPI
 	Region      string
 	VPCIds      []string
 	DhcpOptions map[string]DHCPOption
 }
 
-func (v *EC2DhcpOption) Init(session *session.Session) {
-	v.Client = ec2.New(session)
+func (v *EC2DhcpOption) InitV2(cfg aws.Config) {
+	v.Client = ec2.NewFromConfig(cfg)
 	v.DhcpOptions = make(map[string]DHCPOption)
 }
 
+func (v *EC2DhcpOption) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (v *EC2DhcpOption) ResourceName() string {
 	return "ec2_dhcp_option"
@@ -50,12 +57,12 @@ func (v *EC2DhcpOption) GetAndSetIdentifiers(c context.Context, configObj config
 		return nil, err
 	}
 
-	v.VPCIds = awsgo.StringValueSlice(identifiers)
+	v.VPCIds = aws.ToStringSlice(identifiers)
 	return v.VPCIds, nil
 }
 
 func (v *EC2DhcpOption) Nuke(identifiers []string) error {
-	if err := v.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := v.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/ec2_endpoints.go b/aws/resources/ec2_endpoints.go
index 05c2586..6eaca77 100644
--- a/aws/resources/ec2_endpoints.go
+++ b/aws/resources/ec2_endpoints.go
@@ -5,21 +5,20 @@ import (
 	"fmt"
 	"time"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
 	"github.com/gruntwork-io/cloud-nuke/util"
 	"github.com/gruntwork-io/go-commons/errors"
-	"github.com/gruntwork-io/go-commons/retry"
 )
 
-func ShouldIncludeVpcEndpoint(endpoint *ec2.VpcEndpoint, firstSeenTime *time.Time, configObj config.Config) bool {
+func ShouldIncludeVpcEndpoint(endpoint *types.VpcEndpoint, firstSeenTime *time.Time, configObj config.Config) bool {
 	var endpointName string
 	// get the tags as map
-	tagMap := util.ConvertEC2TagsToMap(endpoint.Tags)
+	tagMap := util.ConvertTypesTagsToMap(endpoint.Tags)
 	if name, ok := tagMap["Name"]; ok {
 		endpointName = name
 	}
@@ -36,29 +35,29 @@ func (e *EC2Endpoints) getAll(c context.Context, configObj config.Config) ([]*st
 
 	var firstSeenTime *time.Time
 	var err error
-	endpoints, err := e.Client.DescribeVpcEndpointsWithContext(e.Context, &ec2.DescribeVpcEndpointsInput{})
+	endpoints, err := e.Client.DescribeVpcEndpoints(e.Context, &ec2.DescribeVpcEndpointsInput{})
 
 	if err != nil {
 		return nil, errors.WithStackTrace(err)
 	}
 
 	for _, endpoint := range endpoints.VpcEndpoints {
-		firstSeenTime, err = util.GetOrCreateFirstSeen(c, e.Client, endpoint.VpcEndpointId, util.ConvertEC2TagsToMap(endpoint.Tags))
+		firstSeenTime, err = util.GetOrCreateFirstSeen(c, e.Client, endpoint.VpcEndpointId, util.ConvertTypesTagsToMap(endpoint.Tags))
 		if err != nil {
 			logging.Error("Unable to retrieve tags")
 			return nil, errors.WithStackTrace(err)
 		}
 
-		if ShouldIncludeVpcEndpoint(endpoint, firstSeenTime, configObj) {
+		if ShouldIncludeVpcEndpoint(&endpoint, firstSeenTime, configObj) {
 			result = append(result, endpoint.VpcEndpointId)
 		}
 
 	}
 
 	e.VerifyNukablePermissions(result, func(id *string) error {
-		_, err := e.Client.DeleteVpcEndpointsWithContext(e.Context, &ec2.DeleteVpcEndpointsInput{
-			VpcEndpointIds: []*string{id},
-			DryRun:         awsgo.Bool(true),
+		_, err := e.Client.DeleteVpcEndpoints(e.Context, &ec2.DeleteVpcEndpointsInput{
+			VpcEndpointIds: []string{aws.ToString(id)},
+			DryRun:         aws.Bool(true),
 		})
 		return err
 	})
@@ -81,11 +80,11 @@ func (e *EC2Endpoints) nukeAll(identifiers []*string) error {
 			continue
 		}
 
-		err := nukeVpcEndpoint(e.Client, []*string{id})
+		err := e.nukeVpcEndpoint([]*string{id})
 
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   awsgo.StringValue(id),
+			Identifier:   aws.ToString(id),
 			ResourceType: "Vpc Endpoint",
 			Error:        err,
 		}
@@ -103,53 +102,18 @@ func (e *EC2Endpoints) nukeAll(identifiers []*string) error {
 	return nil
 }
 
-func nukeVpcEndpoint(client ec2iface.EC2API, endpointIds []*string) error {
-	logging.Debugf("Deleting VPC endpoints %s", awsgo.StringValueSlice(endpointIds))
+func (e *EC2Endpoints) nukeVpcEndpoint(endpointIds []*string) error {
+	logging.Debugf("Deleting VPC endpoints %s", aws.ToStringSlice(endpointIds))
 
-	_, err := client.DeleteVpcEndpoints(&ec2.DeleteVpcEndpointsInput{
-		VpcEndpointIds: endpointIds,
+	_, err := e.Client.DeleteVpcEndpoints(e.Context, &ec2.DeleteVpcEndpointsInput{
+		VpcEndpointIds: aws.ToStringSlice(endpointIds),
 	})
 	if err != nil {
 		logging.Debug(fmt.Sprintf("Failed to delete VPC endpoints: %s", err.Error()))
 		return errors.WithStackTrace(err)
 	}
 
-	logging.Debug(fmt.Sprintf("Successfully deleted VPC endpoints %s",
-		awsgo.StringValueSlice(endpointIds)))
+	logging.Debug(fmt.Sprintf("Successfully deleted VPC endpoints %s", aws.ToStringSlice(endpointIds)))
 
 	return nil
 }
-
-func waitForVPCEndpointToBeDeleted(client ec2iface.EC2API, vpcID string) error {
-	return retry.DoWithRetry(
-		logging.Logger.WithTime(time.Now()),
-		"Waiting for all VPC endpoints to be deleted",
-		10,
-		2*time.Second,
-		func() error {
-			endpoints, err := client.DescribeVpcEndpoints(
-				&ec2.DescribeVpcEndpointsInput{
-					Filters: []*ec2.Filter{
-						{
-							Name:   awsgo.String("vpc-id"),
-							Values: []*string{awsgo.String(vpcID)},
-						},
-						{
-							Name:   awsgo.String("vpc-endpoint-state"),
-							Values: []*string{awsgo.String("deleting")},
-						},
-					},
-				},
-			)
-			if err != nil {
-				return err
-			}
-
-			if len(endpoints.VpcEndpoints) == 0 {
-				return nil
-			}
-			return fmt.Errorf("Not all VPC endpoints deleted.")
-		},
-	)
-	return nil
-}
diff --git a/aws/resources/ec2_endpoints_types.go b/aws/resources/ec2_endpoints_types.go
index 0125bef..de70d14 100644
--- a/aws/resources/ec2_endpoints_types.go
+++ b/aws/resources/ec2_endpoints_types.go
@@ -3,27 +3,31 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// Ec2Endpoint - represents all ec2 endpoints
+type EC2EndpointsAPI interface {
+	DescribeVpcEndpoints(ctx context.Context, params *ec2.DescribeVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error)
+	DeleteVpcEndpoints(ctx context.Context, params *ec2.DeleteVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error)
+}
+
+// EC2Endpoints - represents all ec2 endpoints
 type EC2Endpoints struct {
 	BaseAwsResource
-	Client    ec2iface.EC2API
+	Client    EC2EndpointsAPI
 	Region    string
 	Endpoints []string
 }
 
-func (e *EC2Endpoints) Init(session *session.Session) {
-	e.BaseAwsResource.Init(session)
-	e.Client = ec2.New(session)
+func (e *EC2Endpoints) InitV2(cfg aws.Config) {
+	e.Client = ec2.NewFromConfig(cfg)
 }
 
+func (e *EC2Endpoints) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (e *EC2Endpoints) ResourceName() string {
 	return "ec2-endpoint"
@@ -34,7 +38,6 @@ func (e *EC2Endpoints) MaxBatchSize() int {
 	return 49
 }
 
-// ResourceIdentifiers
 func (e *EC2Endpoints) ResourceIdentifiers() []string {
 	return e.Endpoints
 }
@@ -49,13 +52,13 @@ func (e *EC2Endpoints) GetAndSetIdentifiers(c context.Context, configObj config.
 		return nil, err
 	}
 
-	e.Endpoints = awsgo.StringValueSlice(identifiers)
+	e.Endpoints = aws.ToStringSlice(identifiers)
 	return e.Endpoints, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (e *EC2Endpoints) Nuke(identifiers []string) error {
-	if err := e.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := e.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/ec2_key_pair.go b/aws/resources/ec2_key_pair.go
index c8940ca..c2dd70d 100644
--- a/aws/resources/ec2_key_pair.go
+++ b/aws/resources/ec2_key_pair.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/util"
@@ -14,7 +14,7 @@ import (
 
 // getAllEc2KeyPairs extracts the list of existing ec2 key pairs.
 func (k *EC2KeyPairs) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	result, err := k.Client.DescribeKeyPairsWithContext(k.Context, &ec2.DescribeKeyPairsInput{})
+	result, err := k.Client.DescribeKeyPairs(k.Context, &ec2.DescribeKeyPairsInput{})
 	if err != nil {
 		return nil, errors.WithStackTrace(err)
 	}
@@ -24,7 +24,7 @@ func (k *EC2KeyPairs) getAll(c context.Context, configObj config.Config) ([]*str
 		if configObj.EC2KeyPairs.ShouldInclude(config.ResourceValue{
 			Name: keyPair.KeyName,
 			Time: keyPair.CreateTime,
-			Tags: util.ConvertEC2TagsToMap(keyPair.Tags),
+			Tags: util.ConvertTypesTagsToMap(keyPair.Tags),
 		}) {
 			ids = append(ids, keyPair.KeyPairId)
 		}
@@ -32,9 +32,9 @@ func (k *EC2KeyPairs) getAll(c context.Context, configObj config.Config) ([]*str
 
 	// checking the nukable permissions
 	k.VerifyNukablePermissions(ids, func(id *string) error {
-		_, err := k.Client.DeleteKeyPairWithContext(k.Context, &ec2.DeleteKeyPairInput{
+		_, err := k.Client.DeleteKeyPair(k.Context, &ec2.DeleteKeyPairInput{
 			KeyPairId: id,
-			DryRun:    awsgo.Bool(true),
+			DryRun:    aws.Bool(true),
 		})
 		return err
 	})
@@ -48,7 +48,7 @@ func (k *EC2KeyPairs) deleteKeyPair(keyPairId *string) error {
 		KeyPairId: keyPairId,
 	}
 
-	_, err := k.Client.DeleteKeyPairWithContext(k.Context, params)
+	_, err := k.Client.DeleteKeyPair(k.Context, params)
 	if err != nil {
 		return errors.WithStackTrace(err)
 	}
@@ -68,8 +68,8 @@ func (k *EC2KeyPairs) nukeAll(keypairIds []*string) error {
 	deletedKeyPairs := 0
 	var multiErr *multierror.Error
 	for _, keypair := range keypairIds {
-		if nukable, reason := k.IsNukable(awsgo.StringValue(keypair)); !nukable {
-			logging.Debugf("[Skipping] %s nuke because %v", awsgo.StringValue(keypair), reason)
+		if nukable, reason := k.IsNukable(aws.ToString(keypair)); !nukable {
+			logging.Debugf("[Skipping] %s nuke because %v", aws.ToString(keypair), reason)
 			continue
 		}
 
diff --git a/aws/resources/ec2_key_pair_types.go b/aws/resources/ec2_key_pair_types.go
index c84174a..fda2226 100644
--- a/aws/resources/ec2_key_pair_types.go
+++ b/aws/resources/ec2_key_pair_types.go
@@ -3,25 +3,30 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type EC2KeyPairsAPI interface {
+	DeleteKeyPair(ctx context.Context, params *ec2.DeleteKeyPairInput, optFns ...func(*ec2.Options)) (*ec2.DeleteKeyPairOutput, error)
+	DescribeKeyPairs(ctx context.Context, params *ec2.DescribeKeyPairsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeKeyPairsOutput, error)
+}
+
 type EC2KeyPairs struct {
 	BaseAwsResource
-	Client     ec2iface.EC2API
+	Client     EC2KeyPairsAPI
 	Region     string
 	KeyPairIds []string
 }
 
-func (k *EC2KeyPairs) Init(session *session.Session) {
-	k.Client = ec2.New(session)
+func (k *EC2KeyPairs) InitV2(cfg aws.Config) {
+	k.Client = ec2.NewFromConfig(cfg)
 }
 
+func (k *EC2KeyPairs) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (k *EC2KeyPairs) ResourceName() string {
 	return "ec2-keypairs"
@@ -47,12 +52,12 @@ func (k *EC2KeyPairs) GetAndSetIdentifiers(c context.Context, configObj config.C
 		return nil, err
 	}
 
-	k.KeyPairIds = awsgo.StringValueSlice(identifiers)
+	k.KeyPairIds = aws.ToStringSlice(identifiers)
 	return k.KeyPairIds, nil
 }
 
 func (k *EC2KeyPairs) Nuke(identifiers []string) error {
-	if err := k.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := k.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/ec2_placement_group.go b/aws/resources/ec2_placement_group.go
index 5ccc14d..690650b 100644
--- a/aws/resources/ec2_placement_group.go
+++ b/aws/resources/ec2_placement_group.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"time"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/util"
@@ -14,16 +14,16 @@ import (
 )
 
 // getAll extracts the list of existing ec2 placement groups
-func (p *EC2PlacementGroups) getAll(c context.Context, configObj config.Config) ([]*string, error) {
+func (k *EC2PlacementGroups) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var names []*string
 	var firstSeenTime *time.Time
 
-	result, err := p.Client.DescribePlacementGroupsWithContext(p.Context, &ec2.DescribePlacementGroupsInput{})
+	result, err := k.Client.DescribePlacementGroups(k.Context, &ec2.DescribePlacementGroupsInput{})
 	if err != nil {
 		return nil, errors.WithStackTrace(err)
 	}
 	for _, placementGroup := range result.PlacementGroups {
-		firstSeenTime, err = util.GetOrCreateFirstSeen(c, p.Client, placementGroup.GroupId, util.ConvertEC2TagsToMap(placementGroup.Tags))
+		firstSeenTime, err = util.GetOrCreateFirstSeen(c, k.Client, placementGroup.GroupId, util.ConvertTypesTagsToMap(placementGroup.Tags))
 		if err != nil {
 			logging.Error("Unable to retrieve tags")
 			return nil, errors.WithStackTrace(err)
@@ -32,17 +32,17 @@ func (p *EC2PlacementGroups) getAll(c context.Context, configObj config.Config)
 		if configObj.EC2PlacementGroups.ShouldInclude(config.ResourceValue{
 			Name: placementGroup.GroupName,
 			Time: firstSeenTime,
-			Tags: util.ConvertEC2TagsToMap(placementGroup.Tags),
+			Tags: util.ConvertTypesTagsToMap(placementGroup.Tags),
 		}) {
 			names = append(names, placementGroup.GroupName)
 		}
 	}
 
 	// checking the nukable permissions
-	p.VerifyNukablePermissions(names, func(name *string) error {
-		_, err := p.Client.DeletePlacementGroupWithContext(p.Context, &ec2.DeletePlacementGroupInput{
+	k.VerifyNukablePermissions(names, func(name *string) error {
+		_, err := k.Client.DeletePlacementGroup(k.Context, &ec2.DeletePlacementGroupInput{
 			GroupName: name,
-			DryRun:    awsgo.Bool(true),
+			DryRun:    aws.Bool(true),
 		})
 		return err
 	})
@@ -51,12 +51,12 @@ func (p *EC2PlacementGroups) getAll(c context.Context, configObj config.Config)
 }
 
 // deleteKeyPair is a helper method that deletes the given ec2 key pair.
-func (p *EC2PlacementGroups) deletePlacementGroup(placementGroupName *string) error {
+func (k *EC2PlacementGroups) deletePlacementGroup(placementGroupName *string) error {
 	params := &ec2.DeletePlacementGroupInput{
 		GroupName: placementGroupName,
 	}
 
-	_, err := p.Client.DeletePlacementGroupWithContext(p.Context, params)
+	_, err := k.Client.DeletePlacementGroup(k.Context, params)
 	if err != nil {
 		return errors.WithStackTrace(err)
 	}
@@ -65,23 +65,23 @@ func (p *EC2PlacementGroups) deletePlacementGroup(placementGroupName *string) er
 }
 
 // nukeAllEc2KeyPairs attempts to delete given ec2 key pair IDs.
-func (p *EC2PlacementGroups) nukeAll(groupNames []*string) error {
+func (k *EC2PlacementGroups) nukeAll(groupNames []*string) error {
 	if len(groupNames) == 0 {
-		logging.Infof("No EC2 placement groups to nuke in region %s", p.Region)
+		logging.Infof("No EC2 placement groups to nuke in region %s", k.Region)
 		return nil
 	}
 
-	logging.Infof("Terminating all EC2 placement groups in region %s", p.Region)
+	logging.Infof("Terminating all EC2 placement groups in region %s", k.Region)
 
 	deletedPlacementGroups := 0
 	var multiErr *multierror.Error
 	for _, groupName := range groupNames {
-		if nukable, reason := p.IsNukable(awsgo.StringValue(groupName)); !nukable {
-			logging.Debugf("[Skipping] %s nuke because %v", awsgo.StringValue(groupName), reason)
+		if nukable, reason := k.IsNukable(aws.ToString(groupName)); !nukable {
+			logging.Debugf("[Skipping] %s nuke because %v", aws.ToString(groupName), reason)
 			continue
 		}
 
-		if err := p.deletePlacementGroup(groupName); err != nil {
+		if err := k.deletePlacementGroup(groupName); err != nil {
 			logging.Errorf("[Failed] %s", err)
 			multiErr = multierror.Append(multiErr, err)
 		} else {
diff --git a/aws/resources/ec2_placement_group_types.go b/aws/resources/ec2_placement_group_types.go
index 928a36a..00fad86 100644
--- a/aws/resources/ec2_placement_group_types.go
+++ b/aws/resources/ec2_placement_group_types.go
@@ -3,25 +3,30 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type EC2PlacementGroupsAPI interface {
+	DescribePlacementGroups(ctx context.Context, params *ec2.DescribePlacementGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribePlacementGroupsOutput, error)
+	DeletePlacementGroup(ctx context.Context, params *ec2.DeletePlacementGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeletePlacementGroupOutput, error)
+}
+
 type EC2PlacementGroups struct {
 	BaseAwsResource
-	Client              ec2iface.EC2API
+	Client              EC2PlacementGroupsAPI
 	Region              string
 	PlacementGroupNames []string
 }
 
-func (k *EC2PlacementGroups) Init(session *session.Session) {
-	k.Client = ec2.New(session)
+func (k *EC2PlacementGroups) InitV2(cfg aws.Config) {
+	k.Client = ec2.NewFromConfig(cfg)
 }
 
+func (k *EC2PlacementGroups) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (k *EC2PlacementGroups) ResourceName() string {
 	return "ec2-placement-groups"
@@ -47,12 +52,12 @@ func (k *EC2PlacementGroups) GetAndSetIdentifiers(c context.Context, configObj c
 		return nil, err
 	}
 
-	k.PlacementGroupNames = awsgo.StringValueSlice(identifiers)
+	k.PlacementGroupNames = aws.ToStringSlice(identifiers)
 	return k.PlacementGroupNames, nil
 }
 
 func (k *EC2PlacementGroups) Nuke(identifiers []string) error {
-	if err := k.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := k.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/ec2_vpc.go b/aws/resources/ec2_vpc.go
index f04c543..d3599c6 100644
--- a/aws/resources/ec2_vpc.go
+++ b/aws/resources/ec2_vpc.go
@@ -945,3 +945,53 @@ func nukeEc2Instances(client ec2iface.EC2API, vpcID string) error {
 	logging.Debug(fmt.Sprintf("Successfully deleted instances for %s", vpcID))
 	return nil
 }
+
+func waitForVPCEndpointToBeDeleted(client ec2iface.EC2API, vpcID string) error {
+	return retry.DoWithRetry(
+		logging.Logger.WithTime(time.Now()),
+		"Waiting for all VPC endpoints to be deleted",
+		10,
+		2*time.Second,
+		func() error {
+			endpoints, err := client.DescribeVpcEndpoints(
+				&ec2.DescribeVpcEndpointsInput{
+					Filters: []*ec2.Filter{
+						{
+							Name:   awsgo.String("vpc-id"),
+							Values: []*string{awsgo.String(vpcID)},
+						},
+						{
+							Name:   awsgo.String("vpc-endpoint-state"),
+							Values: []*string{awsgo.String("deleting")},
+						},
+					},
+				},
+			)
+			if err != nil {
+				return err
+			}
+
+			if len(endpoints.VpcEndpoints) == 0 {
+				return nil
+			}
+			return fmt.Errorf("not all VPC endpoints deleted")
+		},
+	)
+}
+
+func nukeVpcEndpoint(client ec2iface.EC2API, endpointIds []*string) error {
+	logging.Debugf("Deleting VPC endpoints %s", awsgo.StringValueSlice(endpointIds))
+
+	_, err := client.DeleteVpcEndpoints(&ec2.DeleteVpcEndpointsInput{
+		VpcEndpointIds: endpointIds,
+	})
+	if err != nil {
+		logging.Debug(fmt.Sprintf("Failed to delete VPC endpoints: %s", err.Error()))
+		return errors.WithStackTrace(err)
+	}
+
+	logging.Debug(fmt.Sprintf("Successfully deleted VPC endpoints %s",
+		awsgo.StringValueSlice(endpointIds)))
+
+	return nil
+}
diff --git a/aws/resources/kinesis_firehose.go b/aws/resources/kinesis_firehose.go
index 20be21b..cc16987 100644
--- a/aws/resources/kinesis_firehose.go
+++ b/aws/resources/kinesis_firehose.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/firehose"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/firehose"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -12,21 +12,20 @@ import (
 )
 
 func (kf *KinesisFirehose) getAll(_ context.Context, configObj config.Config) ([]*string, error) {
-	allStreams := []*string{}
-	output, err := kf.Client.ListDeliveryStreamsWithContext(kf.Context, &firehose.ListDeliveryStreamsInput{})
+	var allStreams []*string
+	output, err := kf.Client.ListDeliveryStreams(kf.Context, &firehose.ListDeliveryStreamsInput{})
+	if err != nil {
+		return nil, errors.WithStackTrace(err)
+	}
 
 	for _, stream := range output.DeliveryStreamNames {
 		if configObj.KinesisFirehose.ShouldInclude(config.ResourceValue{
-			Name: stream,
+			Name: aws.String(stream),
 		}) {
-			allStreams = append(allStreams, stream)
+			allStreams = append(allStreams, aws.String(stream))
 		}
 	}
 
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
-	}
-
 	return allStreams, nil
 }
 
@@ -39,12 +38,12 @@ func (kf *KinesisFirehose) nukeAll(identifiers []*string) error {
 	logging.Debugf("Deleting all Kinesis Firhose in region %s", kf.Region)
 	var deleted []*string
 	for _, id := range identifiers {
-		_, err := kf.Client.DeleteDeliveryStreamWithContext(kf.Context, &firehose.DeleteDeliveryStreamInput{
-			AllowForceDelete:   awsgo.Bool(true),
+		_, err := kf.Client.DeleteDeliveryStream(kf.Context, &firehose.DeleteDeliveryStreamInput{
+			AllowForceDelete:   aws.Bool(true),
 			DeliveryStreamName: id,
 		})
 		e := report.Entry{
-			Identifier:   awsgo.StringValue(id),
+			Identifier:   aws.ToString(id),
 			ResourceType: "Kinesis Firehose",
 			Error:        err,
 		}
diff --git a/aws/resources/kinesis_firehose_types.go b/aws/resources/kinesis_firehose_types.go
index bc00a39..78a86a1 100644
--- a/aws/resources/kinesis_firehose_types.go
+++ b/aws/resources/kinesis_firehose_types.go
@@ -3,25 +3,30 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/firehose"
-	"github.com/aws/aws-sdk-go/service/firehose/firehoseiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/firehose"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type KinesisFirehoseAPI interface {
+	DeleteDeliveryStream(ctx context.Context, params *firehose.DeleteDeliveryStreamInput, optFns ...func(*firehose.Options)) (*firehose.DeleteDeliveryStreamOutput, error)
+	ListDeliveryStreams(ctx context.Context, params *firehose.ListDeliveryStreamsInput, optFns ...func(*firehose.Options)) (*firehose.ListDeliveryStreamsOutput, error)
+}
+
 type KinesisFirehose struct {
 	BaseAwsResource
-	Client firehoseiface.FirehoseAPI
+	Client KinesisFirehoseAPI
 	Region string
 	Names  []string
 }
 
-func (kf *KinesisFirehose) Init(session *session.Session) {
-	kf.Client = firehose.New(session)
+func (kf *KinesisFirehose) InitV2(cfg aws.Config) {
+	kf.Client = firehose.NewFromConfig(cfg)
 }
 
+func (kf *KinesisFirehose) IsUsingV2() bool { return true }
+
 // ResourceName - The simple name of the AWS resource
 func (kf *KinesisFirehose) ResourceName() string {
 	return "kinesis-firehose"
@@ -49,7 +54,7 @@ func (kf *KinesisFirehose) GetAndSetIdentifiers(c context.Context, configObj con
 		return nil, err
 	}
 
-	kf.Names = aws.StringValueSlice(identifiers)
+	kf.Names = aws.ToStringSlice(identifiers)
 	return kf.Names, nil
 }
 
diff --git a/aws/resources/kinesis_stream.go b/aws/resources/kinesis_stream.go
index 639efa3..52cee50 100644
--- a/aws/resources/kinesis_stream.go
+++ b/aws/resources/kinesis_stream.go
@@ -4,9 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/kinesis"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kinesis"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -15,20 +14,22 @@ import (
 )
 
 func (ks *KinesisStreams) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	allStreams := []*string{}
-	err := ks.Client.ListStreamsPagesWithContext(ks.Context, &kinesis.ListStreamsInput{}, func(page *kinesis.ListStreamsOutput, lastPage bool) bool {
+	var allStreams []*string
+
+	paginator := kinesis.NewListStreamsPaginator(ks.Client, &kinesis.ListStreamsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
 		for _, stream := range page.StreamNames {
 			if configObj.KinesisStream.ShouldInclude(config.ResourceValue{
-				Name: stream,
+				Name: aws.String(stream),
 			}) {
-				allStreams = append(allStreams, stream)
+				allStreams = append(allStreams, aws.String(stream))
 			}
 		}
-
-		return !lastPage
-	})
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
 	}
 
 	return allStreams, nil
@@ -66,9 +67,7 @@ func (ks *KinesisStreams) nukeAll(identifiers []*string) error {
 	var allErrs *multierror.Error
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
-			if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() != "OperationAbortedException" {
-				allErrs = multierror.Append(allErrs, err)
-			}
+			allErrs = multierror.Append(allErrs, err)
 		}
 	}
 	finalErr := allErrs.ErrorOrNil()
@@ -85,11 +84,11 @@ func (ks *KinesisStreams) deleteAsync(
 ) {
 	defer wg.Done()
 	input := &kinesis.DeleteStreamInput{StreamName: streamName}
-	_, err := ks.Client.DeleteStreamWithContext(ks.Context, input)
+	_, err := ks.Client.DeleteStream(ks.Context, input)
 
 	// Record status of this resource
 	e := report.Entry{
-		Identifier:   aws.StringValue(streamName),
+		Identifier:   aws.ToString(streamName),
 		ResourceType: "Kinesis Stream",
 		Error:        err,
 	}
@@ -97,7 +96,7 @@ func (ks *KinesisStreams) deleteAsync(
 
 	errChan <- err
 
-	streamNameStr := aws.StringValue(streamName)
+	streamNameStr := aws.ToString(streamName)
 	if err == nil {
 		logging.Debugf("[OK] Kinesis Stream %s delete in %s", streamNameStr, ks.Region)
 	} else {
diff --git a/aws/resources/kinesis_stream_types.go b/aws/resources/kinesis_stream_types.go
index a4de86b..1732324 100644
--- a/aws/resources/kinesis_stream_types.go
+++ b/aws/resources/kinesis_stream_types.go
@@ -3,26 +3,31 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/kinesis"
-	"github.com/aws/aws-sdk-go/service/kinesis/kinesisiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kinesis"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type KinesisStreamsAPI interface {
+	ListStreams(ctx context.Context, params *kinesis.ListStreamsInput, optFns ...func(*kinesis.Options)) (*kinesis.ListStreamsOutput, error)
+	DeleteStream(ctx context.Context, params *kinesis.DeleteStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.DeleteStreamOutput, error)
+}
+
 // KinesisStreams - represents all Kinesis streams
 type KinesisStreams struct {
 	BaseAwsResource
-	Client kinesisiface.KinesisAPI
+	Client KinesisStreamsAPI
 	Region string
 	Names  []string
 }
 
-func (ks *KinesisStreams) Init(session *session.Session) {
-	ks.Client = kinesis.New(session)
+func (ks *KinesisStreams) InitV2(cfg aws.Config) {
+	ks.Client = kinesis.NewFromConfig(cfg)
 }
 
+func (ks *KinesisStreams) IsUsingV2() bool { return true }
+
 // ResourceName - The simple name of the AWS resource
 func (ks *KinesisStreams) ResourceName() string {
 	return "kinesis-stream"
@@ -50,7 +55,7 @@ func (ks *KinesisStreams) GetAndSetIdentifiers(c context.Context, configObj conf
 		return nil, err
 	}
 
-	ks.Names = aws.StringValueSlice(identifiers)
+	ks.Names = aws.ToStringSlice(identifiers)
 	return ks.Names, nil
 }
 
diff --git a/aws/resources/kms_customer_key.go b/aws/resources/kms_customer_key.go
index 22fc1fc..db0b573 100644
--- a/aws/resources/kms_customer_key.go
+++ b/aws/resources/kms_customer_key.go
@@ -4,12 +4,12 @@ import (
 	"context"
 	"sync"
 
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kms"
+	"github.com/aws/aws-sdk-go-v2/service/kms/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
-	"github.com/gruntwork-io/cloud-nuke/report"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/kms"
 	"github.com/gruntwork-io/cloud-nuke/logging"
+	"github.com/gruntwork-io/cloud-nuke/report"
 	"github.com/gruntwork-io/go-commons/errors"
 	"github.com/hashicorp/go-multierror"
 )
@@ -17,20 +17,27 @@ import (
 func (kck *KmsCustomerKeys) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	// Collect all keys in the account
 	var keys []string
-	err := kck.Client.ListKeysPagesWithContext(kck.Context, &kms.ListKeysInput{}, func(page *kms.ListKeysOutput, lastPage bool) bool {
+	listKeysPaginator := kms.NewListKeysPaginator(kck.Client, &kms.ListKeysInput{})
+	for listKeysPaginator.HasMorePages() {
+		page, err := listKeysPaginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
 		for _, key := range page.Keys {
 			keys = append(keys, *key.KeyId)
 		}
-
-		return !lastPage
-	})
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
 	}
 
 	// Collect key to alias mapping
 	keyAliases := map[string][]string{}
-	err = kck.Client.ListAliasesPagesWithContext(kck.Context, &kms.ListAliasesInput{}, func(page *kms.ListAliasesOutput, lastPage bool) bool {
+	listAliasesPaginator := kms.NewListAliasesPaginator(kck.Client, &kms.ListAliasesInput{})
+	for listAliasesPaginator.HasMorePages() {
+		page, err := listAliasesPaginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
 		for _, alias := range page.Aliases {
 			key := alias.TargetKeyId
 			if key == nil {
@@ -45,11 +52,6 @@ func (kck *KmsCustomerKeys) getAll(c context.Context, configObj config.Config) (
 			list = append(list, *alias.AliasName)
 			keyAliases[*key] = list
 		}
-
-		return !lastPage
-	})
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
 	}
 
 	// checking in parallel if keys can be considered for removal
@@ -118,7 +120,7 @@ func (kck *KmsCustomerKeys) shouldInclude(
 			resultsChan <- &KmsCheckIncludeResult{KeyId: ""}
 			return
 		} else {
-			// Set this to true so keys w/o aliases dont bail out
+			// Set this to true so keys w/o aliases don't bail out
 			// On the !includedByName check
 			includedByName = true
 		}
@@ -129,14 +131,14 @@ func (kck *KmsCustomerKeys) shouldInclude(
 		return
 	}
 	// additional request to describe key and get information about creation date, removal status
-	details, err := kck.Client.DescribeKeyWithContext(kck.Context, &kms.DescribeKeyInput{KeyId: &key})
+	details, err := kck.Client.DescribeKey(kck.Context, &kms.DescribeKeyInput{KeyId: &key})
 	if err != nil {
 		resultsChan <- &KmsCheckIncludeResult{Error: err}
 		return
 	}
 	metadata := details.KeyMetadata
 	// evaluate only user keys
-	if *metadata.KeyManager != kms.KeyManagerTypeCustomer {
+	if metadata.KeyManager != types.KeyManagerTypeCustomer {
 		resultsChan <- &KmsCheckIncludeResult{KeyId: ""}
 		return
 	}
@@ -199,7 +201,7 @@ func (kck *KmsCustomerKeys) deleteAliases(wg *sync.WaitGroup, aliases []string)
 
 	for _, aliasName := range aliases {
 		input := &kms.DeleteAliasInput{AliasName: &aliasName}
-		_, err := kck.Client.DeleteAlias(input)
+		_, err := kck.Client.DeleteAlias(kck.Context, input)
 
 		if err != nil {
 			logging.Errorf("[Failed] Failed deleting alias: %s", aliasName)
@@ -211,12 +213,12 @@ func (kck *KmsCustomerKeys) deleteAliases(wg *sync.WaitGroup, aliases []string)
 
 func (kck *KmsCustomerKeys) requestKeyDeletion(wg *sync.WaitGroup, errChan chan error, key *string) {
 	defer wg.Done()
-	input := &kms.ScheduleKeyDeletionInput{KeyId: key, PendingWindowInDays: aws.Int64(int64(kmsRemovalWindow))}
-	_, err := kck.Client.ScheduleKeyDeletionWithContext(kck.Context, input)
+	input := &kms.ScheduleKeyDeletionInput{KeyId: key, PendingWindowInDays: aws.Int32(int32(kmsRemovalWindow))}
+	_, err := kck.Client.ScheduleKeyDeletion(kck.Context, input)
 
 	// Record status of this resource
 	e := report.Entry{
-		Identifier:   aws.StringValue(key),
+		Identifier:   aws.ToString(key),
 		ResourceType: "Key Management Service (KMS) Key",
 		Error:        err,
 	}
diff --git a/aws/resources/kms_customer_key_types.go b/aws/resources/kms_customer_key_types.go
index 4b7abed..b53d365 100644
--- a/aws/resources/kms_customer_key_types.go
+++ b/aws/resources/kms_customer_key_types.go
@@ -3,10 +3,8 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/kms"
-	"github.com/aws/aws-sdk-go/service/kms/kmsiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kms"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
@@ -15,18 +13,28 @@ import (
 // must be between 7 and 30, inclusive
 const kmsRemovalWindow = 7
 
+type KmsCustomerKeysAPI interface {
+	ListKeys(ctx context.Context, params *kms.ListKeysInput, optFns ...func(*kms.Options)) (*kms.ListKeysOutput, error)
+	ListAliases(ctx context.Context, params *kms.ListAliasesInput, optFns ...func(*kms.Options)) (*kms.ListAliasesOutput, error)
+	DescribeKey(ctx context.Context, params *kms.DescribeKeyInput, optFns ...func(*kms.Options)) (*kms.DescribeKeyOutput, error)
+	DeleteAlias(ctx context.Context, params *kms.DeleteAliasInput, optFns ...func(*kms.Options)) (*kms.DeleteAliasOutput, error)
+	ScheduleKeyDeletion(ctx context.Context, params *kms.ScheduleKeyDeletionInput, optFns ...func(*kms.Options)) (*kms.ScheduleKeyDeletionOutput, error)
+}
+
 type KmsCustomerKeys struct {
 	BaseAwsResource
-	Client     kmsiface.KMSAPI
+	Client     KmsCustomerKeysAPI
 	Region     string
 	KeyIds     []string
 	KeyAliases map[string][]string
 }
 
-func (kck *KmsCustomerKeys) Init(session *session.Session) {
-	kck.Client = kms.New(session)
+func (kck *KmsCustomerKeys) InitV2(cfg aws.Config) {
+	kck.Client = kms.NewFromConfig(cfg)
 }
 
+func (kck *KmsCustomerKeys) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (kck *KmsCustomerKeys) ResourceName() string {
 	return "kmscustomerkeys"
@@ -48,13 +56,13 @@ func (kck *KmsCustomerKeys) GetAndSetIdentifiers(c context.Context, configObj co
 		return nil, err
 	}
 
-	kck.KeyIds = awsgo.StringValueSlice(identifiers)
+	kck.KeyIds = aws.ToStringSlice(identifiers)
 	return kck.KeyIds, nil
 }
 
 // Nuke - remove all customer managed keys
 func (kck *KmsCustomerKeys) Nuke(keyIds []string) error {
-	if err := kck.nukeAll(awsgo.StringSlice(keyIds)); err != nil {
+	if err := kck.nukeAll(aws.StringSlice(keyIds)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/lambda.go b/aws/resources/lambda.go
index 0d22668..1675f7f 100644
--- a/aws/resources/lambda.go
+++ b/aws/resources/lambda.go
@@ -4,42 +4,41 @@ import (
 	"context"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/lambda"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/lambda"
+	"github.com/aws/aws-sdk-go-v2/service/lambda/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
+	"github.com/gruntwork-io/go-commons/errors"
 )
 
 func (lf *LambdaFunctions) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var names []*string
 
-	err := lf.Client.ListFunctionsPagesWithContext(
-		lf.Context,
-		&lambda.ListFunctionsInput{}, func(page *lambda.ListFunctionsOutput, lastPage bool) bool {
-			for _, lambda := range page.Functions {
-				if lf.shouldInclude(lambda, configObj) {
-					names = append(names, lambda.FunctionName)
-				}
-			}
-
-			return !lastPage
-		})
+	paginator := lambda.NewListFunctionsPaginator(lf.Client, &lambda.ListFunctionsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
 
-	if err != nil {
-		return nil, err
+		for _, name := range page.Functions {
+			if lf.shouldInclude(&name, configObj) {
+				names = append(names, name.FunctionName)
+			}
+		}
 	}
 
 	return names, nil
 }
 
-func (lf *LambdaFunctions) shouldInclude(lambdaFn *lambda.FunctionConfiguration, configObj config.Config) bool {
+func (lf *LambdaFunctions) shouldInclude(lambdaFn *types.FunctionConfiguration, configObj config.Config) bool {
 	if lambdaFn == nil {
 		return false
 	}
 
-	fnLastModified := aws.StringValue(lambdaFn.LastModified)
+	fnLastModified := aws.ToString(lambdaFn.LastModified)
 	fnName := lambdaFn.FunctionName
 	layout := "2006-01-02T15:04:05.000+0000"
 	lastModifiedDateTime, err := time.Parse(layout, fnLastModified)
@@ -61,18 +60,18 @@ func (lf *LambdaFunctions) nukeAll(names []*string) error {
 	}
 
 	logging.Debugf("Deleting all Lambda Functions in region %s", lf.Region)
-	deletedNames := []*string{}
+	var deletedNames []*string
 
 	for _, name := range names {
 		params := &lambda.DeleteFunctionInput{
 			FunctionName: name,
 		}
 
-		_, err := lf.Client.DeleteFunctionWithContext(lf.Context, params)
+		_, err := lf.Client.DeleteFunction(lf.Context, params)
 
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   aws.StringValue(name),
+			Identifier:   aws.ToString(name),
 			ResourceType: "Lambda function",
 			Error:        err,
 		}
@@ -82,7 +81,7 @@ func (lf *LambdaFunctions) nukeAll(names []*string) error {
 			logging.Errorf("[Failed] %s: %s", *name, err)
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Debugf("Deleted Lambda Function: %s", awsgo.StringValue(name))
+			logging.Debugf("Deleted Lambda Function: %s", aws.ToString(name))
 		}
 	}
 
diff --git a/aws/resources/lambda_layer.go b/aws/resources/lambda_layer.go
index 53c2331..6bb7c3e 100644
--- a/aws/resources/lambda_layer.go
+++ b/aws/resources/lambda_layer.go
@@ -4,70 +4,68 @@ import (
 	"context"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/lambda"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/lambda"
+	"github.com/aws/aws-sdk-go-v2/service/lambda/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
+	"github.com/gruntwork-io/go-commons/errors"
 )
 
 func (ll *LambdaLayers) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	var layers []*lambda.LayersListItem
+	var layers []types.LayersListItem
 	var names []*string
 
-	err := ll.Client.ListLayersPagesWithContext(
-		ll.Context,
-		&lambda.ListLayersInput{}, func(page *lambda.ListLayersOutput, lastPage bool) bool {
-			for _, layer := range page.Layers {
-				logging.Logger.Debugf("Found layer! %s", layer)
-
-				if ll.shouldInclude(layer, configObj) {
-					layers = append(layers, layer)
-				}
-			}
+	paginator := lambda.NewListLayersPaginator(ll.Client, &lambda.ListLayersInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
 
-			return !lastPage
-		})
+		for _, layer := range page.Layers {
+			logging.Logger.Debugf("Found layer! %s", *layer.LayerName)
 
-	if err != nil {
-		return nil, err
+			if ll.shouldInclude(&layer, configObj) {
+				layers = append(layers, layer)
+			}
+		}
 	}
 
 	for _, layer := range layers {
-		err := ll.Client.ListLayerVersionsPagesWithContext(
-			ll.Context,
-			&lambda.ListLayerVersionsInput{
-				LayerName: layer.LayerName,
-			}, func(page *lambda.ListLayerVersionsOutput, lastPage bool) bool {
-				for _, version := range page.LayerVersions {
-					logging.Logger.Debugf("Found layer version! %s", version)
-
-					// Currently the output is just the identifier which is the layer's name.
-					// There could be potentially multiple rows of the same identifier or
-					// layer name since there can be multiple versions of it.
-					names = append(names, layer.LayerName)
-				}
 
-				return !lastPage
-			})
+		versionsPaginator := lambda.NewListLayerVersionsPaginator(ll.Client, &lambda.ListLayerVersionsInput{
+			LayerName: layer.LayerName,
+		})
+		for versionsPaginator.HasMorePages() {
+			page, err := versionsPaginator.NextPage(c)
+			if err != nil {
+				return nil, errors.WithStackTrace(err)
+			}
+
+			for _, version := range page.LayerVersions {
+				logging.Logger.Debugf("Found layer version! %d", version.Version)
 
-		if err != nil {
-			return nil, err
+				// Currently the output is just the identifier which is the layer's name.
+				// There could be potentially multiple rows of the same identifier or
+				// layer name since there can be multiple versions of it.
+				names = append(names, layer.LayerName)
+			}
 		}
 	}
 
 	return names, nil
 }
 
-func (ll *LambdaLayers) shouldInclude(lambdaLayer *lambda.LayersListItem, configObj config.Config) bool {
+func (ll *LambdaLayers) shouldInclude(lambdaLayer *types.LayersListItem, configObj config.Config) bool {
 	if lambdaLayer == nil {
 		return false
 	}
 
 	// Lambda layers are immutable, so the created date of the latest version
 	// is on par with last modified
-	fnLastModified := aws.StringValue(lambdaLayer.LatestMatchingVersion.CreatedDate)
+	fnLastModified := aws.ToString(lambdaLayer.LatestMatchingVersion.CreatedDate)
 	fnName := lambdaLayer.LayerName
 	layout := "2006-01-02T15:04:05.000+0000"
 	lastModifiedDateTime, err := time.Parse(layout, fnLastModified)
@@ -89,39 +87,37 @@ func (ll *LambdaLayers) nukeAll(names []*string) error {
 	}
 
 	logging.Logger.Debugf("Deleting all Lambda Layers in region %s", ll.Region)
-	deletedNames := []*string{}
-	deleteLayerVersions := []*lambda.DeleteLayerVersionInput{}
+	var deletedNames []*string
+	var deleteLayerVersions []*lambda.DeleteLayerVersionInput
 
 	for _, name := range names {
-		err := ll.Client.ListLayerVersionsPagesWithContext(
-			ll.Context,
-			&lambda.ListLayerVersionsInput{
-				LayerName: name,
-			}, func(page *lambda.ListLayerVersionsOutput, lastPage bool) bool {
-				for _, version := range page.LayerVersions {
-					logging.Logger.Debugf("Found layer version! %s", version)
-					params := &lambda.DeleteLayerVersionInput{
-						LayerName:     name,
-						VersionNumber: version.Version,
-					}
-					deleteLayerVersions = append(deleteLayerVersions, params)
-				}
-
-				return !lastPage
-			})
+		paginator := lambda.NewListLayerVersionsPaginator(ll.Client, &lambda.ListLayerVersionsInput{
+			LayerName: name,
+		})
+		for paginator.HasMorePages() {
+			page, err := paginator.NextPage(ll.Context)
+			if err != nil {
+				return errors.WithStackTrace(err)
+			}
 
-		if err != nil {
-			return err
+			for _, version := range page.LayerVersions {
+				logging.Logger.Debugf("Found layer version! %s", *version.LayerVersionArn)
+				params := &lambda.DeleteLayerVersionInput{
+					LayerName:     name,
+					VersionNumber: aws.Int64(version.Version),
+				}
+				deleteLayerVersions = append(deleteLayerVersions, params)
+			}
 		}
 	}
 
 	for _, params := range deleteLayerVersions {
 
-		_, err := ll.Client.DeleteLayerVersionWithContext(ll.Context, params)
+		_, err := ll.Client.DeleteLayerVersion(ll.Context, params)
 
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   aws.StringValue(params.LayerName),
+			Identifier:   aws.ToString(params.LayerName),
 			ResourceType: "Lambda layer",
 			Error:        err,
 		}
@@ -131,7 +127,7 @@ func (ll *LambdaLayers) nukeAll(names []*string) error {
 			logging.Logger.Errorf("[Failed] %s: %s", *params.LayerName, err)
 		} else {
 			deletedNames = append(deletedNames, params.LayerName)
-			logging.Logger.Debugf("Deleted Lambda Layer: %s", awsgo.StringValue(params.LayerName))
+			logging.Logger.Debugf("Deleted Lambda Layer: %s", aws.ToString(params.LayerName))
 		}
 	}
 
diff --git a/aws/resources/lambda_layer_types.go b/aws/resources/lambda_layer_types.go
index 176ccb6..5d4b7b8 100644
--- a/aws/resources/lambda_layer_types.go
+++ b/aws/resources/lambda_layer_types.go
@@ -3,56 +3,62 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/lambda"
-	"github.com/aws/aws-sdk-go/service/lambda/lambdaiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/lambda"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type LambdaLayersAPI interface {
+	DeleteLayerVersion(ctx context.Context, params *lambda.DeleteLayerVersionInput, optFns ...func(*lambda.Options)) (*lambda.DeleteLayerVersionOutput, error)
+	ListLayers(ctx context.Context, params *lambda.ListLayersInput, optFns ...func(*lambda.Options)) (*lambda.ListLayersOutput, error)
+	ListLayerVersions(ctx context.Context, params *lambda.ListLayerVersionsInput, optFns ...func(*lambda.Options)) (*lambda.ListLayerVersionsOutput, error)
+}
+
 type LambdaLayers struct {
 	BaseAwsResource
-	Client              lambdaiface.LambdaAPI
+	Client              LambdaLayersAPI
 	Region              string
 	LambdaFunctionNames []string
 }
 
-func (lf *LambdaLayers) Init(session *session.Session) {
-	lf.Client = lambda.New(session)
+func (ll *LambdaLayers) InitV2(cfg aws.Config) {
+	ll.Client = lambda.NewFromConfig(cfg)
 }
 
-func (lf *LambdaLayers) ResourceName() string {
+func (ll *LambdaLayers) IsUsingV2() bool { return true }
+
+func (ll *LambdaLayers) ResourceName() string {
 	return "lambda_layer"
 }
 
 // ResourceIdentifiers - The names of the lambda functions
-func (lf *LambdaLayers) ResourceIdentifiers() []string {
-	return lf.LambdaFunctionNames
+func (ll *LambdaLayers) ResourceIdentifiers() []string {
+	return ll.LambdaFunctionNames
 }
 
-func (lf *LambdaLayers) MaxBatchSize() int {
+func (ll *LambdaLayers) MaxBatchSize() int {
 	// Tentative batch size to ensure AWS doesn't throttle
 	return 49
 }
 
-func (lf *LambdaLayers) GetAndSetResourceConfig(configObj config.Config) config.ResourceType {
+func (ll *LambdaLayers) GetAndSetResourceConfig(configObj config.Config) config.ResourceType {
 	return configObj.LambdaLayer
 }
 
-func (lf *LambdaLayers) GetAndSetIdentifiers(c context.Context, configObj config.Config) ([]string, error) {
-	identifiers, err := lf.getAll(c, configObj)
+func (ll *LambdaLayers) GetAndSetIdentifiers(c context.Context, configObj config.Config) ([]string, error) {
+	identifiers, err := ll.getAll(c, configObj)
 	if err != nil {
 		return nil, err
 	}
 
-	lf.LambdaFunctionNames = awsgo.StringValueSlice(identifiers)
-	return lf.LambdaFunctionNames, nil
+	ll.LambdaFunctionNames = aws.ToStringSlice(identifiers)
+	return ll.LambdaFunctionNames, nil
 }
 
 // Nuke - nuke 'em all!!!
-func (lf *LambdaLayers) Nuke(identifiers []string) error {
-	if err := lf.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+func (ll *LambdaLayers) Nuke(identifiers []string) error {
+	if err := ll.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/lambda_types.go b/aws/resources/lambda_types.go
index 406e095..95bd5ce 100644
--- a/aws/resources/lambda_types.go
+++ b/aws/resources/lambda_types.go
@@ -3,25 +3,30 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/lambda"
-	"github.com/aws/aws-sdk-go/service/lambda/lambdaiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/lambda"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type LambdaFunctionsAPI interface {
+	DeleteFunction(ctx context.Context, params *lambda.DeleteFunctionInput, optFns ...func(*lambda.Options)) (*lambda.DeleteFunctionOutput, error)
+	ListFunctions(ctx context.Context, params *lambda.ListFunctionsInput, optFns ...func(*lambda.Options)) (*lambda.ListFunctionsOutput, error)
+}
+
 type LambdaFunctions struct {
 	BaseAwsResource
-	Client              lambdaiface.LambdaAPI
+	Client              LambdaFunctionsAPI
 	Region              string
 	LambdaFunctionNames []string
 }
 
-func (lf *LambdaFunctions) Init(session *session.Session) {
-	lf.Client = lambda.New(session)
+func (lf *LambdaFunctions) InitV2(cfg aws.Config) {
+	lf.Client = lambda.NewFromConfig(cfg)
 }
 
+func (lf *LambdaFunctions) IsUsingV2() bool { return true }
+
 func (lf *LambdaFunctions) ResourceName() string {
 	return "lambda"
 }
@@ -46,13 +51,13 @@ func (lf *LambdaFunctions) GetAndSetIdentifiers(c context.Context, configObj con
 		return nil, err
 	}
 
-	lf.LambdaFunctionNames = awsgo.StringValueSlice(identifiers)
+	lf.LambdaFunctionNames = aws.ToStringSlice(identifiers)
 	return lf.LambdaFunctionNames, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (lf *LambdaFunctions) Nuke(identifiers []string) error {
-	if err := lf.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := lf.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/macie.go b/aws/resources/macie.go
index 2076531..8ca4df8 100644
--- a/aws/resources/macie.go
+++ b/aws/resources/macie.go
@@ -6,9 +6,8 @@ import (
 
 	"github.com/gruntwork-io/cloud-nuke/config"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/macie2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/macie2"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
 	"github.com/gruntwork-io/go-commons/errors"
@@ -20,7 +19,7 @@ import (
 func (mm *MacieMember) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var macieStatus []*string
 
-	output, err := mm.Client.GetMacieSessionWithContext(mm.Context, &macie2.GetMacieSessionInput{})
+	output, err := mm.Client.GetMacieSession(mm.Context, &macie2.GetMacieSessionInput{})
 	if err != nil {
 		// If Macie is not enabled when we call GetMacieSession, we get back an error
 		// so we should ignore the error if it's just telling us the account/region is not
@@ -36,7 +35,7 @@ func (mm *MacieMember) getAll(c context.Context, configObj config.Config) ([]*st
 	if configObj.MacieMember.ShouldInclude(config.ResourceValue{
 		Time: output.CreatedAt,
 	}) {
-		macieStatus = append(macieStatus, output.Status)
+		macieStatus = append(macieStatus, aws.String(string(output.Status)))
 	}
 
 	return macieStatus, nil
@@ -46,7 +45,7 @@ func (mm *MacieMember) getAllMacieMembers() ([]*string, error) {
 	var memberAccountIds []*string
 
 	// OnlyAssociated=false input parameter includes "pending" invite members
-	members, err := mm.Client.ListMembersWithContext(mm.Context, &macie2.ListMembersInput{OnlyAssociated: aws.String("false")})
+	members, err := mm.Client.ListMembers(mm.Context, &macie2.ListMembersInput{OnlyAssociated: aws.String("false")})
 	if err != nil {
 		return nil, errors.WithStackTrace(err)
 	}
@@ -54,8 +53,8 @@ func (mm *MacieMember) getAllMacieMembers() ([]*string, error) {
 		memberAccountIds = append(memberAccountIds, member.AccountId)
 	}
 
-	for awsgo.StringValue(members.NextToken) != "" {
-		members, err = mm.Client.ListMembersWithContext(mm.Context, &macie2.ListMembersInput{NextToken: members.NextToken})
+	for aws.ToString(members.NextToken) != "" {
+		members, err = mm.Client.ListMembers(mm.Context, &macie2.ListMembersInput{NextToken: members.NextToken})
 		if err != nil {
 			return nil, errors.WithStackTrace(err)
 		}
@@ -71,14 +70,14 @@ func (mm *MacieMember) removeMacieMembers(memberAccountIds []*string) error {
 
 	// Member accounts must first be disassociated
 	for _, accountId := range memberAccountIds {
-		_, err := mm.Client.DisassociateMemberWithContext(mm.Context, &macie2.DisassociateMemberInput{Id: accountId})
+		_, err := mm.Client.DisassociateMember(mm.Context, &macie2.DisassociateMemberInput{Id: accountId})
 		if err != nil {
 			return err
 		}
 		logging.Debugf("%s member account disassociated", *accountId)
 
 		// Once disassociated, member accounts can be deleted
-		_, err = mm.Client.DeleteMemberWithContext(mm.Context, &macie2.DeleteMemberInput{Id: accountId})
+		_, err = mm.Client.DeleteMember(mm.Context, &macie2.DeleteMemberInput{Id: accountId})
 		if err != nil {
 			return err
 		}
@@ -107,7 +106,7 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 
 	// Check for an administrator account
 	// Macie cannot be disabled with an active administrator account
-	adminAccount, err := mm.Client.GetAdministratorAccountWithContext(mm.Context, &macie2.GetAdministratorAccountInput{})
+	adminAccount, err := mm.Client.GetAdministratorAccount(mm.Context, &macie2.GetAdministratorAccountInput{})
 	if err != nil {
 		if strings.Contains(err.Error(), "there isn't a delegated Macie administrator") {
 			logging.Debugf("No delegated Macie administrator found to remove.")
@@ -118,18 +117,18 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 
 	// Disassociate administrator account if it exists
 	if adminAccount.Administrator != nil {
-		_, err := mm.Client.DisassociateFromAdministratorAccountWithContext(mm.Context, &macie2.DisassociateFromAdministratorAccountInput{})
+		_, err := mm.Client.DisassociateFromAdministratorAccount(mm.Context, &macie2.DisassociateFromAdministratorAccountInput{})
 		if err != nil {
 			logging.Errorf("[Failed] Failed to disassociate from administrator account")
 		}
 	}
 
 	// Disable Macie
-	_, err = mm.Client.DisableMacieWithContext(mm.Context, &macie2.DisableMacieInput{})
+	_, err = mm.Client.DisableMacie(mm.Context, &macie2.DisableMacieInput{})
 	if err != nil {
 		logging.Errorf("[Failed] Failed to disable macie.")
 		e := report.Entry{
-			Identifier:   aws.StringValue(&identifier[0]),
+			Identifier:   aws.ToString(&identifier[0]),
 			ResourceType: "Macie",
 			Error:        err,
 		}
diff --git a/aws/resources/macie_types.go b/aws/resources/macie_types.go
index baff755..7bf635d 100644
--- a/aws/resources/macie_types.go
+++ b/aws/resources/macie_types.go
@@ -3,25 +3,35 @@ package resources
 import (
 	"context"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/macie2"
-	"github.com/aws/aws-sdk-go/service/macie2/macie2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/macie2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type MacieMemberAPI interface {
+	GetMacieSession(ctx context.Context, params *macie2.GetMacieSessionInput, optFns ...func(*macie2.Options)) (*macie2.GetMacieSessionOutput, error)
+	ListMembers(ctx context.Context, params *macie2.ListMembersInput, optFns ...func(*macie2.Options)) (*macie2.ListMembersOutput, error)
+	DisassociateMember(ctx context.Context, params *macie2.DisassociateMemberInput, optFns ...func(*macie2.Options)) (*macie2.DisassociateMemberOutput, error)
+	DeleteMember(ctx context.Context, params *macie2.DeleteMemberInput, optFns ...func(*macie2.Options)) (*macie2.DeleteMemberOutput, error)
+	GetAdministratorAccount(ctx context.Context, params *macie2.GetAdministratorAccountInput, optFns ...func(*macie2.Options)) (*macie2.GetAdministratorAccountOutput, error)
+	DisassociateFromAdministratorAccount(ctx context.Context, params *macie2.DisassociateFromAdministratorAccountInput, optFns ...func(*macie2.Options)) (*macie2.DisassociateFromAdministratorAccountOutput, error)
+	DisableMacie(ctx context.Context, params *macie2.DisableMacieInput, optFns ...func(*macie2.Options)) (*macie2.DisableMacieOutput, error)
+}
+
 type MacieMember struct {
 	BaseAwsResource
-	Client     macie2iface.Macie2API
+	Client     MacieMemberAPI
 	Region     string
 	AccountIds []string
 }
 
-func (mm *MacieMember) Init(session *session.Session) {
-	mm.Client = macie2.New(session)
+func (mm *MacieMember) InitV2(cfg aws.Config) {
+	mm.Client = macie2.NewFromConfig(cfg)
 }
 
+func (mm *MacieMember) IsUsingV2() bool { return true }
+
 func (mm *MacieMember) ResourceName() string {
 	return "macie-member"
 }
@@ -44,7 +54,7 @@ func (mm *MacieMember) GetAndSetIdentifiers(c context.Context, configObj config.
 		return nil, err
 	}
 
-	mm.AccountIds = awsgo.StringValueSlice(identifiers)
+	mm.AccountIds = aws.ToStringSlice(identifiers)
 	return mm.AccountIds, nil
 }
 
diff --git a/go.mod b/go.mod
index 7127d3e..154c1ac 100644
--- a/go.mod
+++ b/go.mod
@@ -4,43 +4,48 @@ go 1.21
 
 require (
 	github.com/aws/aws-sdk-go v1.49.13
-	github.com/aws/aws-sdk-go-v2 v1.32.3
-	github.com/aws/aws-sdk-go-v2/config v1.28.1
-	github.com/aws/aws-sdk-go-v2/credentials v1.17.42
-	github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.3
-	github.com/aws/aws-sdk-go-v2/service/acm v1.30.3
-	github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.4
-	github.com/aws/aws-sdk-go-v2/service/amp v1.30.0
-	github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.3
-	github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.3
-	github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.3
-	github.com/aws/aws-sdk-go-v2/service/autoscaling v1.47.0
-	github.com/aws/aws-sdk-go-v2/service/backup v1.39.4
-	github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.3
-	github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.3
-	github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.43.0
-	github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.3
-	github.com/aws/aws-sdk-go-v2/service/configservice v1.50.3
-	github.com/aws/aws-sdk-go-v2/service/datasync v1.43.0
-	github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.3
-	github.com/aws/aws-sdk-go-v2/service/ec2 v1.187.0
-	github.com/aws/aws-sdk-go-v2/service/ecr v1.36.3
-	github.com/aws/aws-sdk-go-v2/service/ecs v1.49.0
-	github.com/aws/aws-sdk-go-v2/service/efs v1.33.3
-	github.com/aws/aws-sdk-go-v2/service/eks v1.51.1
-	github.com/aws/aws-sdk-go-v2/service/elasticache v1.43.1
-	github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk v1.28.3
-	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.28.3
-	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.41.0
-	github.com/aws/aws-sdk-go-v2/service/eventbridge v1.35.3
-	github.com/aws/aws-sdk-go-v2/service/guardduty v1.50.1
-	github.com/aws/aws-sdk-go-v2/service/iam v1.37.3
-	github.com/aws/aws-sdk-go-v2/service/scheduler v1.12.3
-	github.com/aws/aws-sdk-go-v2/service/securityhub v1.54.4
-	github.com/aws/aws-sdk-go-v2/service/ses v1.28.3
-	github.com/aws/aws-sdk-go-v2/service/sns v1.33.3
-	github.com/aws/aws-sdk-go-v2/service/sqs v1.36.3
-	github.com/aws/aws-sdk-go-v2/service/vpclattice v1.12.3
+	github.com/aws/aws-sdk-go-v2 v1.32.4
+	github.com/aws/aws-sdk-go-v2/config v1.28.3
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.44
+	github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.5
+	github.com/aws/aws-sdk-go-v2/service/acm v1.30.5
+	github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.6
+	github.com/aws/aws-sdk-go-v2/service/amp v1.30.2
+	github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.5
+	github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.5
+	github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.5
+	github.com/aws/aws-sdk-go-v2/service/autoscaling v1.48.0
+	github.com/aws/aws-sdk-go-v2/service/backup v1.39.6
+	github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.5
+	github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.4
+	github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.43.2
+	github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.5
+	github.com/aws/aws-sdk-go-v2/service/configservice v1.50.5
+	github.com/aws/aws-sdk-go-v2/service/datasync v1.43.2
+	github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.5
+	github.com/aws/aws-sdk-go-v2/service/ec2 v1.187.1
+	github.com/aws/aws-sdk-go-v2/service/ecr v1.36.5
+	github.com/aws/aws-sdk-go-v2/service/ecs v1.49.2
+	github.com/aws/aws-sdk-go-v2/service/efs v1.33.5
+	github.com/aws/aws-sdk-go-v2/service/eks v1.52.0
+	github.com/aws/aws-sdk-go-v2/service/elasticache v1.43.2
+	github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk v1.28.4
+	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.28.4
+	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.41.1
+	github.com/aws/aws-sdk-go-v2/service/eventbridge v1.35.5
+	github.com/aws/aws-sdk-go-v2/service/firehose v1.35.0
+	github.com/aws/aws-sdk-go-v2/service/guardduty v1.51.1
+	github.com/aws/aws-sdk-go-v2/service/iam v1.37.4
+	github.com/aws/aws-sdk-go-v2/service/kinesis v1.32.5
+	github.com/aws/aws-sdk-go-v2/service/kms v1.37.5
+	github.com/aws/aws-sdk-go-v2/service/lambda v1.65.0
+	github.com/aws/aws-sdk-go-v2/service/macie2 v1.43.5
+	github.com/aws/aws-sdk-go-v2/service/scheduler v1.12.5
+	github.com/aws/aws-sdk-go-v2/service/securityhub v1.54.6
+	github.com/aws/aws-sdk-go-v2/service/ses v1.28.4
+	github.com/aws/aws-sdk-go-v2/service/sns v1.33.4
+	github.com/aws/aws-sdk-go-v2/service/sqs v1.37.0
+	github.com/aws/aws-sdk-go-v2/service/vpclattice v1.12.5
 	github.com/aws/smithy-go v1.22.0
 	github.com/charmbracelet/lipgloss v0.6.0
 	github.com/go-errors/errors v1.4.2
@@ -58,17 +63,17 @@ require (
 	atomicgo.dev/cursor v0.1.1 // indirect
 	atomicgo.dev/keyboard v0.2.8 // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.18 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.22 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.22 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.19 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.23 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.23 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.22 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.23 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.24.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.32.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.24.5 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.32.4 // indirect
 	github.com/containerd/console v1.0.3 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
diff --git a/go.sum b/go.sum
index 13825b4..33f7b5e 100644
--- a/go.sum
+++ b/go.sum
@@ -15,104 +15,114 @@ github.com/MarvinJWendt/testza v0.4.2/go.mod h1:mSdhXiKH8sg/gQehJ63bINcCKp7RtYew
 github.com/atomicgo/cursor v0.0.1/go.mod h1:cBON2QmmrysudxNBFthvMtN32r3jxVRIvzkUiF/RuIk=
 github.com/aws/aws-sdk-go v1.49.13 h1:f4mGztsgnx2dR9r8FQYa9YW/RsKb+N7bgef4UGrOW1Y=
 github.com/aws/aws-sdk-go v1.49.13/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk=
-github.com/aws/aws-sdk-go-v2 v1.32.3 h1:T0dRlFBKcdaUPGNtkBSwHZxrtis8CQU17UpNBZYd0wk=
-github.com/aws/aws-sdk-go-v2 v1.32.3/go.mod h1:2SK5n0a2karNTv5tbP1SjsX0uhttou00v/HpXKM1ZUo=
+github.com/aws/aws-sdk-go-v2 v1.32.4 h1:S13INUiTxgrPueTmrm5DZ+MiAo99zYzHEFh1UNkOxNE=
+github.com/aws/aws-sdk-go-v2 v1.32.4/go.mod h1:2SK5n0a2karNTv5tbP1SjsX0uhttou00v/HpXKM1ZUo=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6 h1:pT3hpW0cOHRJx8Y0DfJUEQuqPild8jRGmSFmBgvydr0=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6/go.mod h1:j/I2++U0xX+cr44QjHay4Cvxj6FUbnxrgmqN3H1jTZA=
-github.com/aws/aws-sdk-go-v2/config v1.28.1 h1:oxIvOUXy8x0U3fR//0eq+RdCKimWI900+SV+10xsCBw=
-github.com/aws/aws-sdk-go-v2/config v1.28.1/go.mod h1:bRQcttQJiARbd5JZxw6wG0yIK3eLeSCPdg6uqmmlIiI=
-github.com/aws/aws-sdk-go-v2/credentials v1.17.42 h1:sBP0RPjBU4neGpIYyx8mkU2QqLPl5u9cmdTWVzIpHkM=
-github.com/aws/aws-sdk-go-v2/credentials v1.17.42/go.mod h1:FwZBfU530dJ26rv9saAbxa9Ej3eF/AK0OAY86k13n4M=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.18 h1:68jFVtt3NulEzojFesM/WVarlFpCaXLKaBxDpzkQ9OQ=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.18/go.mod h1:Fjnn5jQVIo6VyedMc0/EhPpfNlPl7dHV916O6B+49aE=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.22 h1:Jw50LwEkVjuVzE1NzkhNKkBf9cRN7MtE1F/b2cOKTUM=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.22/go.mod h1:Y/SmAyPcOTmpeVaWSzSKiILfXTVJwrGmYZhcRbhWuEY=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.22 h1:981MHwBaRZM7+9QSR6XamDzF/o7ouUGxFzr+nVSIhrs=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.22/go.mod h1:1RA1+aBEfn+CAB/Mh0MB6LsdCYCnjZm7tKXtnk499ZQ=
+github.com/aws/aws-sdk-go-v2/config v1.28.3 h1:kL5uAptPcPKaJ4q0sDUjUIdueO18Q7JDzl64GpVwdOM=
+github.com/aws/aws-sdk-go-v2/config v1.28.3/go.mod h1:SPEn1KA8YbgQnwiJ/OISU4fz7+F6Fe309Jf0QTsRCl4=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.44 h1:qqfs5kulLUHUEXlHEZXLJkgGoF3kkUeFUTVA585cFpU=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.44/go.mod h1:0Lm2YJ8etJdEdw23s+q/9wTpOeo2HhNE97XcRa7T8MA=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.19 h1:woXadbf0c7enQ2UGCi8gW/WuKmE0xIzxBF/eD94jMKQ=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.19/go.mod h1:zminj5ucw7w0r65bP6nhyOd3xL6veAUMc3ElGMoLVb4=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.23 h1:A2w6m6Tmr+BNXjDsr7M90zkWjsu4JXHwrzPg235STs4=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.23/go.mod h1:35EVp9wyeANdujZruvHiQUAo9E3vbhnIO1mTCAxMlY0=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.23 h1:pgYW9FCabt2M25MoHYCfMrVY2ghiiBKYWUVXfwZs+sU=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.23/go.mod h1:c48kLgzO19wAu3CPkDWC28JbaJ+hfQlsdl7I2+oqIbk=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 h1:VaRN3TlFdd6KxX1x3ILT5ynH6HvKgqdiXoTxAF4HQcQ=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1/go.mod h1:FbtygfRFze9usAadmnGJNc8KsP346kEe+y2/oyhGAGc=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.22 h1:yV+hCAHZZYJQcwAaszoBNwLbPItHvApxT0kVIw6jRgs=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.22/go.mod h1:kbR1TL8llqB1eGnVbybcA4/wgScxdylOdyAd51yxPdw=
-github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.3 h1:ScJw+8v6RPTJbuWxowSiUw8xdPL0aQOAbakC6mF1uZU=
-github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.3/go.mod h1:PTv5/X1+6atCKR/vK3kbm9Ra/zzX/T/92Y/4MuL6ArU=
-github.com/aws/aws-sdk-go-v2/service/acm v1.30.3 h1:/7wq5haORYzJUkAbD9Hh4/SGiwupLhPdGqIzf+taLOA=
-github.com/aws/aws-sdk-go-v2/service/acm v1.30.3/go.mod h1:A4UY3eQPhio6VPEfBhrkafy4rSIjQ/aOggqKZYNHv+c=
-github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.4 h1:uWqTNc//8pMepB0qUzu+r13QybLum/uLUqU4cehzCew=
-github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.4/go.mod h1:WVF7A3ipjS/vpzOY09xJDeH8ja+rDbnl5u2mL26rt60=
-github.com/aws/aws-sdk-go-v2/service/amp v1.30.0 h1:1AQM/Lo024FKGTW/iwIDQHV8+5j8/h0iabYm+4jB5Bo=
-github.com/aws/aws-sdk-go-v2/service/amp v1.30.0/go.mod h1:4OQEJHTg0Z2Q32qQUDWquPZKmLagi5/BVzTCYtcnpJo=
-github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.3 h1:81BvgDQ0bYSim7mFZWSwsX0DRkMkxsYGCpgGfEagnks=
-github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.3/go.mod h1:EN7f1IzcWoBfc2wwp8aftbof+ib5uk9b5OO1sQvPwB0=
-github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.3 h1:LNnp0zMnX20sO+lUZ9e7tMRmIk311vgPgH3f6K1XbqU=
-github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.3/go.mod h1:/uJSiw1R5OvrT3OZcdybich8zaFwaTgX3J1B/CaBhwM=
-github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.3 h1:wkQpocpYy3/SqFf8iUO1uB5ICK06sm6ajevvft7ijoQ=
-github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.3/go.mod h1:lOQv8hfiAZCHdi+wNKBKdSqf1yCKzWiOEQNVKoK/Jko=
-github.com/aws/aws-sdk-go-v2/service/autoscaling v1.47.0 h1:3yvZKeDa/slOTk8Gym4ym9u7AKhYAvy0Y00oRE+HRvE=
-github.com/aws/aws-sdk-go-v2/service/autoscaling v1.47.0/go.mod h1:SDmFD5Xuoa8dHPOLakoiURaUXei4zcqrkZ0/myZch/A=
-github.com/aws/aws-sdk-go-v2/service/backup v1.39.4 h1:4JLXjQf1vEDFmGjr2Z+jLFkMvAEb3aHmq4ChiL+npdA=
-github.com/aws/aws-sdk-go-v2/service/backup v1.39.4/go.mod h1:bXVDvryQpYdWh2pqCk0L/RtKSAwucmAqiyByKLPF1W8=
-github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.3 h1:wVATQoy9BnfUTPlcfliv8IVboUxfbFl36tIxjQ6LR3c=
-github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.3/go.mod h1:L6MMlS0mAPMESZ7sZLUAw9jbu0RV72tgO6cXcNW7g/Y=
-github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.3 h1:C6oS3hSFIB1ydz3dhgkZ0HyzWV41qVjNxS/mA0AGLMQ=
-github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.3/go.mod h1:OXYzq1k1XwhwghGdHASEDeFr0Ij8dyFRaIy6w0yrIms=
-github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.43.0 h1:nrCD0LVzOlmD4KLxvrZf1E/4K+jj1gBp7ljLQLGZZkk=
-github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.43.0/go.mod h1:t/Gxp3yK6TAkcJzsxHLkkaxcNGuLvgFphZiWuSp8qHk=
-github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.3 h1:/yacjNabFPpGw+G+rDgO7NNeT1oaStBD4Nr9bY+veO4=
-github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.3/go.mod h1:oFj+V8EgWsf7cAoJ5j32qEm/hue0rytiHeby//Xzz8g=
-github.com/aws/aws-sdk-go-v2/service/configservice v1.50.3 h1:DxbBEwn87rRW0rey0sraMv9WoTfFIhqNlvg42DaLb9w=
-github.com/aws/aws-sdk-go-v2/service/configservice v1.50.3/go.mod h1:0lMwsdLUdrWOtd8c2KSdjb+fbxHe9k7Nm2BB8VCyM1Q=
-github.com/aws/aws-sdk-go-v2/service/datasync v1.43.0 h1:wTaKnkq96RrLoZhFyrPDDh8Okmq7Qy3vYiHtz1DImuA=
-github.com/aws/aws-sdk-go-v2/service/datasync v1.43.0/go.mod h1:3INRTlR4HqbSlknYo1dOixcspRw6XtwJWL8cQqMGERM=
-github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.3 h1:pS5ka5Z026eG29K3cce+yxG39i5COQARcgheeK9NKQE=
-github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.3/go.mod h1:MBT8rSGSZjJiV6X7rlrVGoIt+mCoaw0VbpdVtsrsJfk=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.187.0 h1:cA4hWo269CN5RY7Arqt8BfzXF0KIN8DSNo/KcqHKkWk=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.187.0/go.mod h1:ossaD9Z1ugYb6sq9QIqQLEOorCGcqUoxlhud9M9yE70=
-github.com/aws/aws-sdk-go-v2/service/ecr v1.36.3 h1:bqmoQEKpWFRDRxOv4lC5yZLc+N1cogZHPLeQACfVUJo=
-github.com/aws/aws-sdk-go-v2/service/ecr v1.36.3/go.mod h1:KwOqlt4MOBK9EpOGkj8RU9fqfTEae5AOUHi1pDEZ3OQ=
-github.com/aws/aws-sdk-go-v2/service/ecs v1.49.0 h1:xhCV6zY5ZFzfyAUOiBXK6wh0HVQTBkvNwA/eiz89ZWY=
-github.com/aws/aws-sdk-go-v2/service/ecs v1.49.0/go.mod h1:RXYd/Ts+sFnjDrVdAZsAfHVkYxQUxhC+l2zrSpSgCGc=
-github.com/aws/aws-sdk-go-v2/service/efs v1.33.3 h1:PvOnbQfS7gR6x9e3THv9k441t0Pyk2Se8TvVWedz6EM=
-github.com/aws/aws-sdk-go-v2/service/efs v1.33.3/go.mod h1:lgRqCGG4HGimYuAkEjtzekYr7xPjq8+BM51wGarbk1c=
-github.com/aws/aws-sdk-go-v2/service/eks v1.51.1 h1:OQjVHkANBbwE055NK49M/kelQbapsQOsSfUUWP1mi3w=
-github.com/aws/aws-sdk-go-v2/service/eks v1.51.1/go.mod h1:9wMtzHTjYbK5MLzYBWSznUPsys/n9LapMwb6UhKOVPQ=
-github.com/aws/aws-sdk-go-v2/service/elasticache v1.43.1 h1:mNdBr6JqVYp0DSjSiO7snzUo5xoczBBfhuUIHIqutgA=
-github.com/aws/aws-sdk-go-v2/service/elasticache v1.43.1/go.mod h1:rPN8bNqTMCKtKxkyVdPra/0J7ecOmRQlBv3BZTq9Fq0=
-github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk v1.28.3 h1:cUhmI37/S8kYMfQrd5JB7zxfbLuXIAJcFJvo//cZLgs=
-github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk v1.28.3/go.mod h1:ERGQhQc/0neux01Q60KOG4/3oRgdBNtOJ7/mYPUpjTY=
-github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.28.3 h1:cRDiIyPNUf71QjW6dFbHApMieS4svBvfTKBiEtzQZrs=
-github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.28.3/go.mod h1:G86bITIZX9wcacVyMHzLz9nEQaQLSBKDHym0spIEr+M=
-github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.41.0 h1:W+xNfPS8dQ8YoszdkHqTDYIgCrWJvyUU/ZgdJ0frCRE=
-github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.41.0/go.mod h1:6WuvTcPjB9gff93p/2LNBg09d8xK99jpVO6+fRSCKEU=
-github.com/aws/aws-sdk-go-v2/service/eventbridge v1.35.3 h1:e/jGXEQi+lyTIhc3s+jbJrq2IWgLXsNbdYxDauWTyPU=
-github.com/aws/aws-sdk-go-v2/service/eventbridge v1.35.3/go.mod h1:607CryyDS58whuaVno9CCg3L/nnWOqorxiyAS2f9leY=
-github.com/aws/aws-sdk-go-v2/service/guardduty v1.50.1 h1:0A05jzCVA6W/UFqdtpKm8KXE8QhcEn/Fn01Zxsq2Owg=
-github.com/aws/aws-sdk-go-v2/service/guardduty v1.50.1/go.mod h1:tfpIzAIeMtSUucGN87ZUA2u5Lqnc04ManYSk3smJpGc=
-github.com/aws/aws-sdk-go-v2/service/iam v1.37.3 h1:uuoXyOwX2ReYgHJW0W84cKDUrvQNQA2l9KhkXUgT+R4=
-github.com/aws/aws-sdk-go-v2/service/iam v1.37.3/go.mod h1:RCrjvkN/ZpVAzW3ZmIlyflv7MUM45YlWx3v+6MaVX2w=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.23 h1:1SZBDiRzzs3sNhOMVApyWPduWYGAX0imGy06XiBnCAM=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.23/go.mod h1:i9TkxgbZmHVh2S0La6CAXtnyFhlCX/pJ0JsOvBAS6Mk=
+github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.5 h1:7Yerkldbhj9wLYZElX0lai8Fi10Y/4tVjRy6aerV5ug=
+github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.5/go.mod h1:7Om7kPFVbASCKvJaFkNN8htYhewIN6Xg2jLFvCv0FrI=
+github.com/aws/aws-sdk-go-v2/service/acm v1.30.5 h1:xT0pAxIVWjR9bFw2xrGpL1lt6eXmXaJ4nxXCYBegs00=
+github.com/aws/aws-sdk-go-v2/service/acm v1.30.5/go.mod h1:Fo90MZbAao/owZjAKO1dhazUlf2EFovI7bxOmoUFqoY=
+github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.6 h1:vdQnPPcXUlVn+RK3USF42E1d0DNWksALKYClSSZ1dZs=
+github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.6/go.mod h1:IzKiMKtWkmw5v2YT1/Z9X+R1yJB2qQpkDYYk6oyRCBs=
+github.com/aws/aws-sdk-go-v2/service/amp v1.30.2 h1:LaxpHhkyOipkHAVXqDuYeZKmkRWRPFEHvJc5Eyrx3do=
+github.com/aws/aws-sdk-go-v2/service/amp v1.30.2/go.mod h1:otnmAIHxbeGx6suqsEixCTh8WGYAZZJH8eLaRgdC9P4=
+github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.5 h1:k2OEUneF50AlKWKXS+1QCpyv9RSf16+pFseg62mmF4Y=
+github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.5/go.mod h1:A9Kc9UFVbe9r6mjVaKZ8Lf4SoY6hj8oZWH9hED+ld6Y=
+github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.5 h1:OF0RdzoygZgFZlYayS575Ynu0H/kJ/cZ1fOwnFrPq4g=
+github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.5/go.mod h1:emC2s+EMBM7GmydOC9dlgoJhqxdAicKJwSFhVggoc7k=
+github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.5 h1:vPv+oYLZf/nTynSL0o03lvroPik0xHTJIzmTxw5KC+4=
+github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.5/go.mod h1:IVcgd5pTOh3T2B7iTrWBk2pfYWXL8+I2tgHoziDEtoA=
+github.com/aws/aws-sdk-go-v2/service/autoscaling v1.48.0 h1:jqGxMEnsD0NHc2Id2H5TB0Fl0hBPJKofhtO6ZSuv18U=
+github.com/aws/aws-sdk-go-v2/service/autoscaling v1.48.0/go.mod h1:DkO2AXbNiahaTv8J/LAwx3ddx/I1Dzxx+YpVB9ONUEU=
+github.com/aws/aws-sdk-go-v2/service/backup v1.39.6 h1:9pJEHqk5XAm+H+mAfj0pld1Xn0Fx2N5ql6hlz+GoEyQ=
+github.com/aws/aws-sdk-go-v2/service/backup v1.39.6/go.mod h1:ojOfXYWv9GyPbT9Q4AA/UzSG0b7DhqDi+vvLARlE5oE=
+github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.5 h1:6ThDGpCuve3xc5GIk88EuB1YJk135KpWpGGYkPO54Tc=
+github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.5/go.mod h1:dMy3o3W5gG5aOON5Y5EMMWeQDby9nFOeU7egskS4rrk=
+github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.4 h1:c60zN18a3zQsBWdwE/v5xhK2Mtl1HG1gj9BLIEFxjWc=
+github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.4/go.mod h1:fkETEwhdw2tOqu5m0Xa3wimV3PLDaiGqNrVZ3MJ7zOc=
+github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.43.2 h1:QaFEWSbTr3n31uaRyMPX2wCuzUGIS+VYM1xv5+I2FRo=
+github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.43.2/go.mod h1:dLKWdVHc4B1v+N6SLYkCUQjE4urPT4abG98sHbR5jnw=
+github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.5 h1:o047pZS9LNdXDPA2Kzw44l7Zk5sn/cghuoIYRhIGFCc=
+github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.5/go.mod h1:BcnpinS3IUvN6GuAU65hSne1d4ZD333EC95KRqdDHhU=
+github.com/aws/aws-sdk-go-v2/service/configservice v1.50.5 h1:u7UiUqnCDH7qSLKBf4UYqa6yZwo1EZtDJRvgOquQHVY=
+github.com/aws/aws-sdk-go-v2/service/configservice v1.50.5/go.mod h1:BaHMRvvaiB0zR500n0jvC2Die+bfaXRLUWR7mo5f6vQ=
+github.com/aws/aws-sdk-go-v2/service/datasync v1.43.2 h1:IQTguEPJ6FNiN0+khEJNak0yGvZxlS/KqfoiRWPZTpM=
+github.com/aws/aws-sdk-go-v2/service/datasync v1.43.2/go.mod h1:qdRLt3qUPw7lbIyF9YwNotDqkK18LYE1ANDXdsZ2gwk=
+github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.5 h1:VWun/99wjelZZ+d0DGeSrffiCBJhC481geypGc6rfn0=
+github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.5/go.mod h1:P+1rrWglInpWvnBpN0pH8jIIhkLkBaolkRVG4X9Kous=
+github.com/aws/aws-sdk-go-v2/service/ec2 v1.187.1 h1:g6N2LDa3UuNR8CZvTYuXUKzfCD6S1iqRIsDFkbtwu0Y=
+github.com/aws/aws-sdk-go-v2/service/ec2 v1.187.1/go.mod h1:0A17IIeys01WfjDKehspGP+Cyo/YH/eNADIbEbRS9yM=
+github.com/aws/aws-sdk-go-v2/service/ecr v1.36.5 h1:FMF/uaTcIdhvOwZXJfzpwanx2m4Dd6IcN4vDnAn7NAA=
+github.com/aws/aws-sdk-go-v2/service/ecr v1.36.5/go.mod h1:xhf509Ba+rG5whtO7w46O0raVzu1Og3Aba80LSvHbbQ=
+github.com/aws/aws-sdk-go-v2/service/ecs v1.49.2 h1:LpxJEwzfI5pen6CbNem8mwPAYBwjoQ/hLHVAqhAEFDo=
+github.com/aws/aws-sdk-go-v2/service/ecs v1.49.2/go.mod h1:zL7o3zbIpWdzjbIZQbir4aGew5QmhiYVkvx6avQnLDc=
+github.com/aws/aws-sdk-go-v2/service/efs v1.33.5 h1:IfaLNIIT1m3q0M2HbP+MqKU/kWt9Cej2VLRFcuk0XGA=
+github.com/aws/aws-sdk-go-v2/service/efs v1.33.5/go.mod h1:yCeKfWPD0na87deTqOQ65g1CXytykczP7QZX4oNFhdo=
+github.com/aws/aws-sdk-go-v2/service/eks v1.52.0 h1:zwtPtUh/eQ1poiEMV2KB7UxuL2dgH8wu7Zlr/kc7WQA=
+github.com/aws/aws-sdk-go-v2/service/eks v1.52.0/go.mod h1:jF64KxW5772dIqCCBEDk+QSzhBiqI9xdpjoso3DpvwQ=
+github.com/aws/aws-sdk-go-v2/service/elasticache v1.43.2 h1:PN61rmiIx5Kx2BTBVwNhQdIDUsGExelKNQb0OnB8X4Y=
+github.com/aws/aws-sdk-go-v2/service/elasticache v1.43.2/go.mod h1:GfBXRmZeda5Rt0KxjAtjxB6wVguM3K8tvGA/SEI51bc=
+github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk v1.28.4 h1:3/A2CI61lDLBRFdSf3/8utIbUB3EBRlgjfSJ6di+RfI=
+github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk v1.28.4/go.mod h1:QfbCIfdq0gazapvRqUu6jWrSH92+r+PfB4drqT7WaPs=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.28.4 h1:Rdrd35iVHabYS45yIrm0NVYpq/hNhdAhB2FiXYCOZyw=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.28.4/go.mod h1:OBFqCwiJoYtdhDdH0S7bKMk7PbM6JYsD7psjAVZ+tVY=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.41.1 h1:EfkdYBfEgJJREyk0fm7C9OrcS+cq9KK7lYvabo4nEMM=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.41.1/go.mod h1:ffdKles8aLKN0GJkZ2LdFKFD1wGs6ZFuu/+Hftv4Xu0=
+github.com/aws/aws-sdk-go-v2/service/eventbridge v1.35.5 h1:O7UMjjX8eAM4eLs303VramU8DW4FzTUJz1EsQKkxqc0=
+github.com/aws/aws-sdk-go-v2/service/eventbridge v1.35.5/go.mod h1:U1Wwh1TVfPHB8sbmBt3yqH2etdYERX1quammRvGWtXs=
+github.com/aws/aws-sdk-go-v2/service/firehose v1.35.0 h1:gMObW4IgUF4z8PxOb8efA/5P/chbjPc4XcTgDwZB/3g=
+github.com/aws/aws-sdk-go-v2/service/firehose v1.35.0/go.mod h1:eC8yjekJg1MXGYwFDX0tYIFnBMMvJVmwuAnrQ6A88IE=
+github.com/aws/aws-sdk-go-v2/service/guardduty v1.51.1 h1:nAK988z7ZsAYHZtVD8IYV1HVI3ZcE2atQCoBEO5xEQE=
+github.com/aws/aws-sdk-go-v2/service/guardduty v1.51.1/go.mod h1:ISU8hcBgCVmpZTUmD2ONSQO+0dGpIjyCU1r+yIy7ha0=
+github.com/aws/aws-sdk-go-v2/service/iam v1.37.4 h1:MrH2MJRzxPGXtavvL1JtDLFJzXN+4ObO090jzauqcPk=
+github.com/aws/aws-sdk-go-v2/service/iam v1.37.4/go.mod h1:WJARDpnEOhixhh41f+kTTr67y28OvjIUVht++rfcILY=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 h1:TToQNkvGguu209puTojY/ozlqy2d/SFNcoLIqTFi42g=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0/go.mod h1:0jp+ltwkf+SwG2fm/PKo8t4y8pJSgOCO4D8Lz3k0aHQ=
-github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.3 h1:wudRPcZMKytcywXERkR6PLqD8gPx754ZyIOo0iVg488=
-github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.3/go.mod h1:yRo5Kj5+m/ScVIZpQOquQvDtSrDM1JLRCnvglBcdNmw=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.3 h1:qcxX0JYlgWH3hpPUnd6U0ikcl6LLA9sLkXE2w1fpMvY=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.3/go.mod h1:cLSNEmI45soc+Ef8K/L+8sEA3A3pYFEYf5B5UI+6bH4=
-github.com/aws/aws-sdk-go-v2/service/scheduler v1.12.3 h1:VrfgbM8+DuUaTRx1Lllajic28bHaaUrYx9tN9JCGXVI=
-github.com/aws/aws-sdk-go-v2/service/scheduler v1.12.3/go.mod h1:0ujC4ruQHlBlToSoHj3s/OL9wr7dp7wPrcACMDc87ME=
-github.com/aws/aws-sdk-go-v2/service/securityhub v1.54.4 h1:/dZV1aa+UyaP17M/gHQ6qHDEnvfHAF98CIXzerGQv9M=
-github.com/aws/aws-sdk-go-v2/service/securityhub v1.54.4/go.mod h1:3Aq0KVVKwxbRdEywQbgQLnVrimltVKejsW1fVMnK2Uc=
-github.com/aws/aws-sdk-go-v2/service/ses v1.28.3 h1:/ioiCUft5rJL1ufmmVq3Qzg198wgzj/NRm6eHFthEAc=
-github.com/aws/aws-sdk-go-v2/service/ses v1.28.3/go.mod h1:IbgnKNoFmzljAdSbce2P4cNT6pLmrdFI+q02Q2PCM7o=
-github.com/aws/aws-sdk-go-v2/service/sns v1.33.3 h1:coZW/SqpINT0VWG8vRWWY9TWUof8TDdxublw2Xur0Zc=
-github.com/aws/aws-sdk-go-v2/service/sns v1.33.3/go.mod h1:J/G2xuhwNBlDvEi0WR/bnBbac4KSgpkERna/IXEF52w=
-github.com/aws/aws-sdk-go-v2/service/sqs v1.36.3 h1:H1bCg79Q4PDtxQH8Fn5kASQlbVv2WGP5o5IEFEBNOAs=
-github.com/aws/aws-sdk-go-v2/service/sqs v1.36.3/go.mod h1:W6Uy6OWgxF9RZuHoikthB6f+A0oYXqnfWmFl5m7E2G4=
-github.com/aws/aws-sdk-go-v2/service/sso v1.24.3 h1:UTpsIf0loCIWEbrqdLb+0RxnTXfWh2vhw4nQmFi4nPc=
-github.com/aws/aws-sdk-go-v2/service/sso v1.24.3/go.mod h1:FZ9j3PFHHAR+w0BSEjK955w5YD2UwB/l/H0yAK3MJvI=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.3 h1:2YCmIXv3tmiItw0LlYf6v7gEHebLY45kBEnPezbUKyU=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.3/go.mod h1:u19stRyNPxGhj6dRm+Cdgu6N75qnbW7+QN0q0dsAk58=
-github.com/aws/aws-sdk-go-v2/service/sts v1.32.3 h1:wVnQ6tigGsRqSWDEEyH6lSAJ9OyFUsSnbaUWChuSGzs=
-github.com/aws/aws-sdk-go-v2/service/sts v1.32.3/go.mod h1:VZa9yTFyj4o10YGsmDO4gbQJUvvhY72fhumT8W4LqsE=
-github.com/aws/aws-sdk-go-v2/service/vpclattice v1.12.3 h1:YwFhhnQNn2bvnJ9HNy7DEhyIf5Ze/9Qn6ad6gtByLko=
-github.com/aws/aws-sdk-go-v2/service/vpclattice v1.12.3/go.mod h1:wjm69e87s+O7nq0zC54dEJ7M9gLHMfr9ZJ+j5u9IV0Q=
+github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.4 h1:rWKH6IiWDRIxmsTJUB/wEY+EIPp+P3C78Vidl+HXp6w=
+github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.4/go.mod h1:MzOAfuiNZ6asjVrA+dNvXl5lI2nmzXakSpDFLOcOyJ4=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.4 h1:tHxQi/XHPK0ctd/wdOw0t7Xrc2OxcRCnVzv8lwWPu0c=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.4/go.mod h1:4GQbF1vJzG60poZqWatZlhP31y8PGCCVTvIGPdaaYJ0=
+github.com/aws/aws-sdk-go-v2/service/kinesis v1.32.5 h1:qlSo29NECbPML9fKL3RZ28XMQB/zw8Fvwa+POkbA08Q=
+github.com/aws/aws-sdk-go-v2/service/kinesis v1.32.5/go.mod h1:2/lI9/4ZEq+wLGLUpbo2LLGYfFv+HGOex3Iu67k7lvU=
+github.com/aws/aws-sdk-go-v2/service/kms v1.37.5 h1:5dQJ6Q5QrQOqZxXjSbRXukBqU8Pgu6Ro6Qqtyd8yiz4=
+github.com/aws/aws-sdk-go-v2/service/kms v1.37.5/go.mod h1:A9vfQcNHVBCE7ZZN6H+UUJpXtbH26Vv6L7Zhk5nIJAY=
+github.com/aws/aws-sdk-go-v2/service/lambda v1.65.0 h1:c4eYRkhqXsyoIQ4Z8e3E1fBmxOB3XnAfbYw0x+kyHdw=
+github.com/aws/aws-sdk-go-v2/service/lambda v1.65.0/go.mod h1:4L6vIpiChdahncljlDFzKWGiZsLgszGwDoYqMDhb6T4=
+github.com/aws/aws-sdk-go-v2/service/macie2 v1.43.5 h1:WJZG9ajCzS93t5qgG3NqVJqJqvpab9frc+2OhEszF/s=
+github.com/aws/aws-sdk-go-v2/service/macie2 v1.43.5/go.mod h1:uAeVP7yiKq1iECAGBsHgMzlUH77OIrmsA1CBmIIeCe4=
+github.com/aws/aws-sdk-go-v2/service/scheduler v1.12.5 h1:iitjgZ+/+ICxhA4EBvT5sqKchDcTiKBSOy+Ow0N8M+U=
+github.com/aws/aws-sdk-go-v2/service/scheduler v1.12.5/go.mod h1:xbnM3QuSlc52qQjTdDK3GptxYgDnGaonugLFdv5opq4=
+github.com/aws/aws-sdk-go-v2/service/securityhub v1.54.6 h1:EXJOAcfyr0atxiQdrHTnrVTCwO9udESAcQ96sWiJ8es=
+github.com/aws/aws-sdk-go-v2/service/securityhub v1.54.6/go.mod h1:6dnbiz9aq9VKUdRM2Sh9Fouoj7BOpIedm8xAYpVpGy8=
+github.com/aws/aws-sdk-go-v2/service/ses v1.28.4 h1:EDhsD67gk5WOUwKoh7ZgwU2OOp3Mm/IyMVVrf5EevOU=
+github.com/aws/aws-sdk-go-v2/service/ses v1.28.4/go.mod h1:J2mxEMBb09SgtslSlV9GUHjvth7nWb2hG1Np5iSIurE=
+github.com/aws/aws-sdk-go-v2/service/sns v1.33.4 h1:Ff0cm9pmWXAZ3dK2hkqnwBGgHDRMDpWZCV8SCXaAvnw=
+github.com/aws/aws-sdk-go-v2/service/sns v1.33.4/go.mod h1:RtivpQUW50BRHRjX66m+ReDisr36Nf9TgsPakzLrpwo=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.37.0 h1:4el/8jdTeg0Rx/ws3yIEPXR1LfSUiMKhdb/WuDwKzKI=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.37.0/go.mod h1:YXj6Y1BjZNj1PKi78CX2hBkVpCCuJ0TRtyd6wrKVQ64=
+github.com/aws/aws-sdk-go-v2/service/sso v1.24.5 h1:HJwZwRt2Z2Tdec+m+fPjvdmkq2s9Ra+VR0hjF7V2o40=
+github.com/aws/aws-sdk-go-v2/service/sso v1.24.5/go.mod h1:wrMCEwjFPms+V86TCQQeOxQF/If4vT44FGIOFiMC2ck=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.4 h1:zcx9LiGWZ6i6pjdcoE9oXAB6mUdeyC36Ia/QEiIvYdg=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.4/go.mod h1:Tp/ly1cTjRLGBBmNccFumbZ8oqpZlpdhFf80SrRh4is=
+github.com/aws/aws-sdk-go-v2/service/sts v1.32.4 h1:yDxvkz3/uOKfxnv8YhzOi9m+2OGIxF+on3KOISbK5IU=
+github.com/aws/aws-sdk-go-v2/service/sts v1.32.4/go.mod h1:9XEUty5v5UAsMiFOBJrNibZgwCeOma73jgGwwhgffa8=
+github.com/aws/aws-sdk-go-v2/service/vpclattice v1.12.5 h1:SR2VyTp+n8uHWJ5gI7aNtgkJc1JVKxv+Xrgu9A/KF0I=
+github.com/aws/aws-sdk-go-v2/service/vpclattice v1.12.5/go.mod h1:t3Ljhmx5GEzD6OGd5ajMgs8L0Wza2Ppe5FE9uqFHLDo=
 github.com/aws/smithy-go v1.22.0 h1:uunKnWlcoL3zO7q+gG2Pk53joueEOsnNB28QdMsmiMM=
 github.com/aws/smithy-go v1.22.0/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
diff --git a/v2_migration_report/output.md b/v2_migration_report/output.md
index ee3701c..74f3d1f 100644
--- a/v2_migration_report/output.md
+++ b/v2_migration_report/output.md
@@ -27,12 +27,12 @@ run `go generate ./...` to refresh this report.
 | dynamodb                         | :white_check_mark: |
 | ebs                              | :white_check_mark: |
 | ec2                              |                    |
-| ec2-dedicated-hosts              |                    |
-| ec2-endpoint                     |                    |
-| ec2-keypairs                     |                    |
-| ec2-placement-groups             |                    |
+| ec2-dedicated-hosts              | :white_check_mark: |
+| ec2-endpoint                     | :white_check_mark: |
+| ec2-keypairs                     | :white_check_mark: |
+| ec2-placement-groups             | :white_check_mark: |
 | ec2-subnet                       |                    |
-| ec2_dhcp_option                  |                    |
+| ec2_dhcp_option                  | :white_check_mark: |
 | ecr                              | :white_check_mark: |
 | ecscluster                       | :white_check_mark: |
 | ecsserv                          | :white_check_mark: |
@@ -64,14 +64,14 @@ run `go generate ./...` to refresh this report.
 | ipam-pool                        |                    |
 | ipam-resource-discovery          |                    |
 | ipam-scope                       |                    |
-| kinesis-firehose                 |                    |
-| kinesis-stream                   |                    |
-| kmscustomerkeys                  |                    |
-| lambda                           |                    |
-| lambda_layer                     |                    |
+| kinesis-firehose                 | :white_check_mark: |
+| kinesis-stream                   | :white_check_mark: |
+| kmscustomerkeys                  | :white_check_mark: |
+| lambda                           | :white_check_mark: |
+| lambda_layer                     | :white_check_mark: |
 | lc                               |                    |
 | lt                               |                    |
-| macie-member                     |                    |
+| macie-member                     | :white_check_mark: |
 | managed-prometheus               | :white_check_mark: |
 | msk-cluster                      |                    |
 | nat-gateway                      |                    |


Test patch:
diff --git a/aws/resources/ec2_dedicated_host_test.go b/aws/resources/ec2_dedicated_host_test.go
index e0cb839..a860811 100644
--- a/aws/resources/ec2_dedicated_host_test.go
+++ b/aws/resources/ec2_dedicated_host_test.go
@@ -7,33 +7,28 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedEC2DedicatedHosts struct {
-	ec2iface.EC2API
-	DescribeHostsPagesOutput ec2.DescribeHostsOutput
-	ReleaseHostsOutput       ec2.ReleaseHostsOutput
+	EC2DedicatedHostsAPI
+	DescribeHostsOutput ec2.DescribeHostsOutput
+	ReleaseHostsOutput  ec2.ReleaseHostsOutput
 }
 
-func (m mockedEC2DedicatedHosts) DescribeHostsPagesWithContext(_ awsgo.Context, _ *ec2.DescribeHostsInput, fn func(*ec2.DescribeHostsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.DescribeHostsPagesOutput, true)
-	return nil
+func (m mockedEC2DedicatedHosts) DescribeHosts(ctx context.Context, params *ec2.DescribeHostsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeHostsOutput, error) {
+	return &m.DescribeHostsOutput, nil
 }
 
-func (m mockedEC2DedicatedHosts) ReleaseHostsWithContext(_ awsgo.Context, _ *ec2.ReleaseHostsInput, _ ...request.Option) (*ec2.ReleaseHostsOutput, error) {
+func (m mockedEC2DedicatedHosts) ReleaseHosts(ctx context.Context, params *ec2.ReleaseHostsInput, optFns ...func(*ec2.Options)) (*ec2.ReleaseHostsOutput, error) {
 	return &m.ReleaseHostsOutput, nil
 }
 
 func TestEC2DedicatedHosts_GetAll(t *testing.T) {
-
 	t.Parallel()
-
 	testId1 := "test-host-id-1"
 	testId2 := "test-host-id-2"
 	testName1 := "test-host-name-1"
@@ -41,27 +36,27 @@ func TestEC2DedicatedHosts_GetAll(t *testing.T) {
 	now := time.Now()
 	h := EC2DedicatedHosts{
 		Client: mockedEC2DedicatedHosts{
-			DescribeHostsPagesOutput: ec2.DescribeHostsOutput{
-				Hosts: []*ec2.Host{
+			DescribeHostsOutput: ec2.DescribeHostsOutput{
+				Hosts: []types.Host{
 					{
-						HostId: awsgo.String(testId1),
-						Tags: []*ec2.Tag{
+						HostId: aws.String(testId1),
+						Tags: []types.Tag{
 							{
-								Key:   awsgo.String("Name"),
-								Value: awsgo.String(testName1),
+								Key:   aws.String("Name"),
+								Value: aws.String(testName1),
 							},
 						},
-						AllocationTime: awsgo.Time(now),
+						AllocationTime: aws.Time(now),
 					},
 					{
-						HostId: awsgo.String(testId2),
-						Tags: []*ec2.Tag{
+						HostId: aws.String(testId2),
+						Tags: []types.Tag{
 							{
-								Key:   awsgo.String("Name"),
-								Value: awsgo.String(testName2),
+								Key:   aws.String("Name"),
+								Value: aws.String(testName2),
 							},
 						},
-						AllocationTime: awsgo.Time(now.Add(1)),
+						AllocationTime: aws.Time(now.Add(1)),
 					},
 				},
 			},
@@ -99,22 +94,20 @@ func TestEC2DedicatedHosts_GetAll(t *testing.T) {
 				EC2DedicatedHosts: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, awsgo.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 
 }
 
 func TestEC2DedicatedHosts_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	h := EC2DedicatedHosts{
 		Client: mockedEC2DedicatedHosts{
 			ReleaseHostsOutput: ec2.ReleaseHostsOutput{},
 		},
 	}
 
-	err := h.nukeAll([]*string{awsgo.String("test-host-id-1"), awsgo.String("test-host-id-2")})
+	err := h.nukeAll([]*string{aws.String("test-host-id-1"), aws.String("test-host-id-2")})
 	require.NoError(t, err)
 }
diff --git a/aws/resources/ec2_dhcp_option_test.go b/aws/resources/ec2_dhcp_option_test.go
index 7e5851f..46c3752 100644
--- a/aws/resources/ec2_dhcp_option_test.go
+++ b/aws/resources/ec2_dhcp_option_test.go
@@ -4,53 +4,47 @@ import (
 	"context"
 	"testing"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedEC2DhcpOption struct {
-	ec2iface.EC2API
+	EC2DhcpOptionAPI
+	AssociateDhcpOptionsOutput ec2.AssociateDhcpOptionsOutput
 	DescribeDhcpOptionsOutput  ec2.DescribeDhcpOptionsOutput
-	DeleteDhcpOptionsOutput    ec2.DeleteDhcpOptionsOutput
 	DescribeVpcsOutput         ec2.DescribeVpcsOutput
-	AssociateDhcpOptionsOutput ec2.AssociateDhcpOptionsOutput
-}
-
-func (m mockedEC2DhcpOption) DescribeDhcpOptionsPagesWithContext(_ awsgo.Context, _ *ec2.DescribeDhcpOptionsInput, fn func(*ec2.DescribeDhcpOptionsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.DescribeDhcpOptionsOutput, true)
-	return nil
+	DeleteDhcpOptionsOutput    ec2.DeleteDhcpOptionsOutput
 }
 
-func (m mockedEC2DhcpOption) DeleteDhcpOptions(_ *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
-	return &m.DeleteDhcpOptionsOutput, nil
+func (m mockedEC2DhcpOption) AssociateDhcpOptions(ctx context.Context, params *ec2.AssociateDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.AssociateDhcpOptionsOutput, error) {
+	return &m.AssociateDhcpOptionsOutput, nil
 }
 
-func (m mockedEC2DhcpOption) DeleteDhcpOptionsWithContext(_ awsgo.Context, _ *ec2.DeleteDhcpOptionsInput, _ ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) {
-	return &m.DeleteDhcpOptionsOutput, nil
+func (m mockedEC2DhcpOption) DescribeDhcpOptions(ctx context.Context, params *ec2.DescribeDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error) {
+	return &m.DescribeDhcpOptionsOutput, nil
 }
 
-func (m mockedEC2DhcpOption) DescribeVpcsWithContext(awsgo.Context, *ec2.DescribeVpcsInput, ...request.Option) (*ec2.DescribeVpcsOutput, error) {
+func (m mockedEC2DhcpOption) DescribeVpcs(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error) {
 	return &m.DescribeVpcsOutput, nil
 }
-func (m mockedEC2DhcpOption) AssociateDhcpOptionsWithContext(awsgo.Context, *ec2.AssociateDhcpOptionsInput, ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) {
-	return &m.AssociateDhcpOptionsOutput, nil
+
+func (m mockedEC2DhcpOption) DeleteDhcpOptions(ctx context.Context, params *ec2.DeleteDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteDhcpOptionsOutput, error) {
+	return &m.DeleteDhcpOptionsOutput, nil
 }
 
 func TestEC2DhcpOption_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testId1 := "test-id-1"
 	h := EC2DhcpOption{
 		Client: mockedEC2DhcpOption{
 			DescribeDhcpOptionsOutput: ec2.DescribeDhcpOptionsOutput{
-				DhcpOptions: []*ec2.DhcpOptions{
+				DhcpOptions: []types.DhcpOptions{
 					{
-						DhcpOptionsId: awsgo.String(testId1),
+						DhcpOptionsId: aws.String(testId1),
 					},
 				},
 			},
@@ -72,22 +66,19 @@ func TestEC2DhcpOption_GetAll(t *testing.T) {
 				EC2DedicatedHosts: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, awsgo.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
-
 }
 
 func TestEC2DhcpOption_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	h := EC2DhcpOption{
 		Client: mockedEC2DhcpOption{
 			DeleteDhcpOptionsOutput: ec2.DeleteDhcpOptionsOutput{},
 		},
 	}
 
-	err := h.nukeAll([]*string{awsgo.String("test-id-1"), awsgo.String("test-id-2")})
+	err := h.nukeAll([]*string{aws.String("test-id-1"), aws.String("test-id-2")})
 	require.NoError(t, err)
 }
diff --git a/aws/resources/ec2_endpoints_test.go b/aws/resources/ec2_endpoints_test.go
index aa77ed7..4a4edb9 100644
--- a/aws/resources/ec2_endpoints_test.go
+++ b/aws/resources/ec2_endpoints_test.go
@@ -6,37 +6,29 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/util"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedEc2VpcEndpoints struct {
-	BaseAwsResource
-	ec2iface.EC2API
-	DeleteVpcEndpointsOutput   ec2.DeleteVpcEndpointsOutput
+	EC2EndpointsAPI
 	DescribeVpcEndpointsOutput ec2.DescribeVpcEndpointsOutput
+	DeleteVpcEndpointsOutput   ec2.DeleteVpcEndpointsOutput
 }
 
-func (m mockedEc2VpcEndpoints) DescribeVpcEndpointsWithContext(_ awsgo.Context, _ *ec2.DescribeVpcEndpointsInput, _ ...request.Option) (*ec2.DescribeVpcEndpointsOutput, error) {
+func (m mockedEc2VpcEndpoints) DescribeVpcEndpoints(ctx context.Context, params *ec2.DescribeVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error) {
 	return &m.DescribeVpcEndpointsOutput, nil
 }
 
-func (m mockedEc2VpcEndpoints) DeleteVpcEndpoints(_ *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) {
-	return &m.DeleteVpcEndpointsOutput, nil
-}
-
-func (m mockedEc2VpcEndpoints) DeleteVpcEndpointsWithContext(_ awsgo.Context, _ *ec2.DeleteVpcEndpointsInput, _ ...request.Option) (*ec2.DeleteVpcEndpointsOutput, error) {
+func (m mockedEc2VpcEndpoints) DeleteVpcEndpoints(ctx context.Context, params *ec2.DeleteVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error) {
 	return &m.DeleteVpcEndpointsOutput, nil
 }
 
 func TestVcpEndpoint_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	// Set excludeFirstSeenTag to false for testing
@@ -53,10 +45,10 @@ func TestVcpEndpoint_GetAll(t *testing.T) {
 	vpcEndpoint := EC2Endpoints{
 		Client: mockedEc2VpcEndpoints{
 			DescribeVpcEndpointsOutput: ec2.DescribeVpcEndpointsOutput{
-				VpcEndpoints: []*ec2.VpcEndpoint{
+				VpcEndpoints: []types.VpcEndpoint{
 					{
 						VpcEndpointId: aws.String(endpoint1),
-						Tags: []*ec2.Tag{
+						Tags: []types.Tag{
 							{
 								Key:   aws.String("Name"),
 								Value: aws.String(testName1),
@@ -68,7 +60,7 @@ func TestVcpEndpoint_GetAll(t *testing.T) {
 					},
 					{
 						VpcEndpointId: aws.String(endpoint2),
-						Tags: []*ec2.Tag{
+						Tags: []types.Tag{
 							{
 								Key:   aws.String("Name"),
 								Value: aws.String(testName2),
@@ -127,16 +119,13 @@ func TestVcpEndpoint_GetAll(t *testing.T) {
 				EC2Endpoint: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
-
 }
 
 func TestEc2Endpoints_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	var (
 		endpoint1 = "vpce-0b201b2dcd4f77a2f001"
 		endpoint2 = "vpce-0b201b2dcd4f77a2f002"
@@ -151,7 +140,7 @@ func TestEc2Endpoints_NukeAll(t *testing.T) {
 		},
 		Client: mockedEc2VpcEndpoints{
 			DescribeVpcEndpointsOutput: ec2.DescribeVpcEndpointsOutput{
-				VpcEndpoints: []*ec2.VpcEndpoint{
+				VpcEndpoints: []types.VpcEndpoint{
 					{
 						VpcEndpointId: aws.String(endpoint1),
 					},
diff --git a/aws/resources/ec2_key_pair_test.go b/aws/resources/ec2_key_pair_test.go
index ce52852..f4d205c 100644
--- a/aws/resources/ec2_key_pair_test.go
+++ b/aws/resources/ec2_key_pair_test.go
@@ -7,32 +7,28 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedEC2KeyPairs struct {
-	ec2iface.EC2API
-	DescribeKeyPairsOutput ec2.DescribeKeyPairsOutput
+	EC2KeyPairsAPI
 	DeleteKeyPairOutput    ec2.DeleteKeyPairOutput
+	DescribeKeyPairsOutput ec2.DescribeKeyPairsOutput
 }
 
-func (m mockedEC2KeyPairs) DescribeKeyPairsWithContext(_ awsgo.Context, _ *ec2.DescribeKeyPairsInput, _ ...request.Option) (*ec2.DescribeKeyPairsOutput, error) {
-	return &m.DescribeKeyPairsOutput, nil
+func (m mockedEC2KeyPairs) DeleteKeyPair(ctx context.Context, params *ec2.DeleteKeyPairInput, optFns ...func(*ec2.Options)) (*ec2.DeleteKeyPairOutput, error) {
+	return &m.DeleteKeyPairOutput, nil
 }
 
-func (m mockedEC2KeyPairs) DeleteKeyPairWithContext(_ awsgo.Context, _ *ec2.DeleteKeyPairInput, _ ...request.Option) (*ec2.DeleteKeyPairOutput, error) {
-	return &m.DeleteKeyPairOutput, nil
+func (m mockedEC2KeyPairs) DescribeKeyPairs(ctx context.Context, params *ec2.DescribeKeyPairsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeKeyPairsOutput, error) {
+	return &m.DescribeKeyPairsOutput, nil
 }
 
 func TestEC2KeyPairs_GetAll(t *testing.T) {
-
 	t.Parallel()
-
 	now := time.Now()
 	testId1 := "test-keypair-id1"
 	testName1 := "test-keypair1"
@@ -41,16 +37,16 @@ func TestEC2KeyPairs_GetAll(t *testing.T) {
 	k := EC2KeyPairs{
 		Client: mockedEC2KeyPairs{
 			DescribeKeyPairsOutput: ec2.DescribeKeyPairsOutput{
-				KeyPairs: []*ec2.KeyPairInfo{
+				KeyPairs: []types.KeyPairInfo{
 					{
-						KeyName:    awsgo.String(testName1),
-						KeyPairId:  awsgo.String(testId1),
-						CreateTime: awsgo.Time(now),
+						KeyName:    aws.String(testName1),
+						KeyPairId:  aws.String(testId1),
+						CreateTime: aws.Time(now),
 					},
 					{
-						KeyName:    awsgo.String(testName2),
-						KeyPairId:  awsgo.String(testId2),
-						CreateTime: awsgo.Time(now.Add(1)),
+						KeyName:    aws.String(testName2),
+						KeyPairId:  aws.String(testId2),
+						CreateTime: aws.Time(now.Add(1)),
 					},
 				},
 			},
@@ -88,21 +84,19 @@ func TestEC2KeyPairs_GetAll(t *testing.T) {
 				EC2KeyPairs: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, awsgo.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestEC2KeyPairs_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	h := EC2KeyPairs{
 		Client: mockedEC2KeyPairs{
 			DeleteKeyPairOutput: ec2.DeleteKeyPairOutput{},
 		},
 	}
 
-	err := h.nukeAll([]*string{awsgo.String("test-keypair-id-1"), awsgo.String("test-keypair-id-2")})
+	err := h.nukeAll([]*string{aws.String("test-keypair-id-1"), aws.String("test-keypair-id-2")})
 	require.NoError(t, err)
 }
diff --git a/aws/resources/ec2_placement_group_test.go b/aws/resources/ec2_placement_group_test.go
index 8fdd834..2c4390c 100644
--- a/aws/resources/ec2_placement_group_test.go
+++ b/aws/resources/ec2_placement_group_test.go
@@ -6,31 +6,29 @@ import (
 	"testing"
 	"time"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/util"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedEC2PlacementGroups struct {
-	ec2iface.EC2API
+	EC2PlacementGroupsAPI
 	DescribePlacementGroupsOutput ec2.DescribePlacementGroupsOutput
 	DeletePlacementGroupOutput    ec2.DeletePlacementGroupOutput
 }
 
-func (m mockedEC2PlacementGroups) DescribePlacementGroupsWithContext(_ awsgo.Context, _ *ec2.DescribePlacementGroupsInput, _ ...request.Option) (*ec2.DescribePlacementGroupsOutput, error) {
+func (m mockedEC2PlacementGroups) DescribePlacementGroups(ctx context.Context, params *ec2.DescribePlacementGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribePlacementGroupsOutput, error) {
 	return &m.DescribePlacementGroupsOutput, nil
 }
 
-func (m mockedEC2PlacementGroups) DeletePlacementGroupWithContext(_ awsgo.Context, _ *ec2.DeletePlacementGroupInput, _ ...request.Option) (*ec2.DeletePlacementGroupOutput, error) {
+func (m mockedEC2PlacementGroups) DeletePlacementGroup(ctx context.Context, params *ec2.DeletePlacementGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeletePlacementGroupOutput, error) {
 	return &m.DeletePlacementGroupOutput, nil
 }
 
 func TestEC2PlacementGroups_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	// Set excludeFirstSeenTag to false for testing
@@ -44,21 +42,21 @@ func TestEC2PlacementGroups_GetAll(t *testing.T) {
 	p := EC2PlacementGroups{
 		Client: mockedEC2PlacementGroups{
 			DescribePlacementGroupsOutput: ec2.DescribePlacementGroupsOutput{
-				PlacementGroups: []*ec2.PlacementGroup{
+				PlacementGroups: []types.PlacementGroup{
 					{
-						GroupName: awsgo.String(testName1),
-						GroupId:   awsgo.String(testId1),
-						Tags: []*ec2.Tag{{
-							Key:   awsgo.String(util.FirstSeenTagKey),
-							Value: awsgo.String(util.FormatTimestamp(now)),
+						GroupName: aws.String(testName1),
+						GroupId:   aws.String(testId1),
+						Tags: []types.Tag{{
+							Key:   aws.String(util.FirstSeenTagKey),
+							Value: aws.String(util.FormatTimestamp(now)),
 						}},
 					},
 					{
-						GroupName: awsgo.String(testName2),
-						GroupId:   awsgo.String(testId2),
-						Tags: []*ec2.Tag{{
-							Key:   awsgo.String(util.FirstSeenTagKey),
-							Value: awsgo.String(util.FormatTimestamp(now.Add(2 * time.Hour))),
+						GroupName: aws.String(testName2),
+						GroupId:   aws.String(testId2),
+						Tags: []types.Tag{{
+							Key:   aws.String(util.FirstSeenTagKey),
+							Value: aws.String(util.FormatTimestamp(now.Add(2 * time.Hour))),
 						}},
 					},
 				},
@@ -90,7 +88,7 @@ func TestEC2PlacementGroups_GetAll(t *testing.T) {
 			ctx: ctx,
 			configObj: config.ResourceType{
 				ExcludeRule: config.FilterRule{
-					TimeAfter: awsgo.Time(now.Add(1 * time.Hour)),
+					TimeAfter: aws.Time(now.Add(1 * time.Hour)),
 				}},
 			expected: []string{testName1},
 		},
@@ -101,21 +99,19 @@ func TestEC2PlacementGroups_GetAll(t *testing.T) {
 				EC2PlacementGroups: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, awsgo.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestEC2PlacementGroups_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	h := EC2PlacementGroups{
 		Client: mockedEC2PlacementGroups{
 			DeletePlacementGroupOutput: ec2.DeletePlacementGroupOutput{},
 		},
 	}
 
-	err := h.nukeAll([]*string{awsgo.String("test-group1"), awsgo.String("test-group2")})
+	err := h.nukeAll([]*string{aws.String("test-group1"), aws.String("test-group2")})
 	require.NoError(t, err)
 }
diff --git a/aws/resources/kinesis_firehose_test.go b/aws/resources/kinesis_firehose_test.go
index 30905cb..c5ce2f5 100644
--- a/aws/resources/kinesis_firehose_test.go
+++ b/aws/resources/kinesis_firehose_test.go
@@ -5,38 +5,34 @@ import (
 	"regexp"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/firehose"
-	"github.com/aws/aws-sdk-go/service/firehose/firehoseiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/firehose"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedKinesisFirehose struct {
-	firehoseiface.FirehoseAPI
-	ListDeliveryStreamsOutput  firehose.ListDeliveryStreamsOutput
+	KinesisFirehoseAPI
 	DeleteDeliveryStreamOutput firehose.DeleteDeliveryStreamOutput
+	ListDeliveryStreamsOutput  firehose.ListDeliveryStreamsOutput
 }
 
-func (m mockedKinesisFirehose) ListDeliveryStreamsWithContext(aws.Context, *firehose.ListDeliveryStreamsInput, ...request.Option) (*firehose.ListDeliveryStreamsOutput, error) {
-	return &m.ListDeliveryStreamsOutput, nil
+func (m mockedKinesisFirehose) DeleteDeliveryStream(ctx context.Context, params *firehose.DeleteDeliveryStreamInput, optFns ...func(*firehose.Options)) (*firehose.DeleteDeliveryStreamOutput, error) {
+	return &m.DeleteDeliveryStreamOutput, nil
 }
 
-func (m mockedKinesisFirehose) DeleteDeliveryStreamWithContext(aws.Context, *firehose.DeleteDeliveryStreamInput, ...request.Option) (*firehose.DeleteDeliveryStreamOutput, error) {
-	return &m.DeleteDeliveryStreamOutput, nil
+func (m mockedKinesisFirehose) ListDeliveryStreams(ctx context.Context, params *firehose.ListDeliveryStreamsInput, optFns ...func(*firehose.Options)) (*firehose.ListDeliveryStreamsOutput, error) {
+	return &m.ListDeliveryStreamsOutput, nil
 }
 
 func TestKinesisFirehoseStreams_GetAll(t *testing.T) {
-
 	t.Parallel()
-
 	testName1 := "stream1"
 	testName2 := "stream2"
 	ks := KinesisFirehose{
 		Client: mockedKinesisFirehose{
 			ListDeliveryStreamsOutput: firehose.ListDeliveryStreamsOutput{
-				DeliveryStreamNames: []*string{aws.String(testName1), aws.String(testName2)},
+				DeliveryStreamNames: []string{testName1, testName2},
 			},
 		},
 	}
@@ -65,16 +61,14 @@ func TestKinesisFirehoseStreams_GetAll(t *testing.T) {
 				KinesisFirehose: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 
 }
 
 func TestKinesisFirehose_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	ks := KinesisFirehose{
 		Client: mockedKinesisFirehose{
 			DeleteDeliveryStreamOutput: firehose.DeleteDeliveryStreamOutput{},
diff --git a/aws/resources/kinesis_stream_test.go b/aws/resources/kinesis_stream_test.go
index 7078277..d45213a 100644
--- a/aws/resources/kinesis_stream_test.go
+++ b/aws/resources/kinesis_stream_test.go
@@ -5,31 +5,27 @@ import (
 	"regexp"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/kinesis"
-	"github.com/aws/aws-sdk-go/service/kinesis/kinesisiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kinesis"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedKinesisClient struct {
-	kinesisiface.KinesisAPI
+	KinesisStreamsAPI
 	ListStreamsOutput  kinesis.ListStreamsOutput
 	DeleteStreamOutput kinesis.DeleteStreamOutput
 }
 
-func (m mockedKinesisClient) ListStreamsPagesWithContext(_ aws.Context, input *kinesis.ListStreamsInput, fn func(*kinesis.ListStreamsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListStreamsOutput, true)
-	return nil
+func (m mockedKinesisClient) ListStreams(ctx context.Context, params *kinesis.ListStreamsInput, optFns ...func(*kinesis.Options)) (*kinesis.ListStreamsOutput, error) {
+	return &m.ListStreamsOutput, nil
 }
 
-func (m mockedKinesisClient) DeleteStreamWithContext(_ aws.Context, input *kinesis.DeleteStreamInput, _ ...request.Option) (*kinesis.DeleteStreamOutput, error) {
+func (m mockedKinesisClient) DeleteStream(ctx context.Context, params *kinesis.DeleteStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.DeleteStreamOutput, error) {
 	return &m.DeleteStreamOutput, nil
 }
 
 func TestKinesisStreams_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "stream1"
@@ -37,7 +33,7 @@ func TestKinesisStreams_GetAll(t *testing.T) {
 	ks := KinesisStreams{
 		Client: mockedKinesisClient{
 			ListStreamsOutput: kinesis.ListStreamsOutput{
-				StreamNames: []*string{aws.String(testName1), aws.String(testName2)},
+				StreamNames: []string{testName1, testName2},
 			},
 		},
 	}
@@ -66,14 +62,13 @@ func TestKinesisStreams_GetAll(t *testing.T) {
 				KinesisStream: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 
 }
 
 func TestKinesisStreams_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	ks := KinesisStreams{
diff --git a/aws/resources/kms_customer_key_test.go b/aws/resources/kms_customer_key_test.go
index 2ea15be..228f9e6 100644
--- a/aws/resources/kms_customer_key_test.go
+++ b/aws/resources/kms_customer_key_test.go
@@ -6,50 +6,45 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/kms"
-	"github.com/aws/aws-sdk-go/service/kms/kmsiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kms"
+	"github.com/aws/aws-sdk-go-v2/service/kms/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedKmsCustomerKeys struct {
-	kmsiface.KMSAPI
-	ListKeysPagesOutput       kms.ListKeysOutput
-	ListAliasesPagesOutput    kms.ListAliasesOutput
+	KmsCustomerKeysAPI
+	ListKeysOutput            kms.ListKeysOutput
+	ListAliasesOutput         kms.ListAliasesOutput
 	DescribeKeyOutput         map[string]kms.DescribeKeyOutput
-	ScheduleKeyDeletionOutput kms.ScheduleKeyDeletionOutput
 	DeleteAliasOutput         kms.DeleteAliasOutput
+	ScheduleKeyDeletionOutput kms.ScheduleKeyDeletionOutput
 }
 
-func (m mockedKmsCustomerKeys) ListKeysPagesWithContext(_ aws.Context, input *kms.ListKeysInput, fn func(*kms.ListKeysOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListKeysPagesOutput, true)
-	return nil
+func (m mockedKmsCustomerKeys) ListKeys(ctx context.Context, params *kms.ListKeysInput, optFns ...func(*kms.Options)) (*kms.ListKeysOutput, error) {
+	return &m.ListKeysOutput, nil
 }
 
-func (m mockedKmsCustomerKeys) ListAliasesPagesWithContext(_ aws.Context, input *kms.ListAliasesInput, fn func(*kms.ListAliasesOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListAliasesPagesOutput, true)
-	return nil
+func (m mockedKmsCustomerKeys) ListAliases(ctx context.Context, params *kms.ListAliasesInput, optFns ...func(*kms.Options)) (*kms.ListAliasesOutput, error) {
+	return &m.ListAliasesOutput, nil
 }
 
-func (m mockedKmsCustomerKeys) DescribeKeyWithContext(_ aws.Context, input *kms.DescribeKeyInput, _ ...request.Option) (*kms.DescribeKeyOutput, error) {
-	id := input.KeyId
+func (m mockedKmsCustomerKeys) DescribeKey(ctx context.Context, params *kms.DescribeKeyInput, optFns ...func(*kms.Options)) (*kms.DescribeKeyOutput, error) {
+	id := params.KeyId
 	output := m.DescribeKeyOutput[*id]
-
 	return &output, nil
 }
 
-func (m mockedKmsCustomerKeys) ScheduleKeyDeletionWithContext(_ aws.Context, input *kms.ScheduleKeyDeletionInput, _ ...request.Option) (*kms.ScheduleKeyDeletionOutput, error) {
-	return &m.ScheduleKeyDeletionOutput, nil
+func (m mockedKmsCustomerKeys) DeleteAlias(ctx context.Context, params *kms.DeleteAliasInput, optFns ...func(*kms.Options)) (*kms.DeleteAliasOutput, error) {
+	return &m.DeleteAliasOutput, nil
 }
 
-func (m mockedKmsCustomerKeys) DeleteAliasWithContext(_ aws.Context, input *kms.DeleteAliasInput, _ ...request.Option) (*kms.DeleteAliasOutput, error) {
-	return &m.DeleteAliasOutput, nil
+func (m mockedKmsCustomerKeys) ScheduleKeyDeletion(ctx context.Context, params *kms.ScheduleKeyDeletionInput, optFns ...func(*kms.Options)) (*kms.ScheduleKeyDeletionOutput, error) {
+	return &m.ScheduleKeyDeletionOutput, nil
 }
 
 func TestKMS_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	key1 := "key1"
@@ -59,8 +54,8 @@ func TestKMS_GetAll(t *testing.T) {
 	now := time.Now()
 	kck := KmsCustomerKeys{
 		Client: mockedKmsCustomerKeys{
-			ListKeysPagesOutput: kms.ListKeysOutput{
-				Keys: []*kms.KeyListEntry{
+			ListKeysOutput: kms.ListKeysOutput{
+				Keys: []types.KeyListEntry{
 					{
 						KeyId: aws.String(key1),
 					},
@@ -69,8 +64,8 @@ func TestKMS_GetAll(t *testing.T) {
 					},
 				},
 			},
-			ListAliasesPagesOutput: kms.ListAliasesOutput{
-				Aliases: []*kms.AliasListEntry{
+			ListAliasesOutput: kms.ListAliasesOutput{
+				Aliases: []types.AliasListEntry{
 					{
 						AliasName:   aws.String(alias1),
 						TargetKeyId: aws.String(key1),
@@ -83,16 +78,16 @@ func TestKMS_GetAll(t *testing.T) {
 			},
 			DescribeKeyOutput: map[string]kms.DescribeKeyOutput{
 				key1: {
-					KeyMetadata: &kms.KeyMetadata{
+					KeyMetadata: &types.KeyMetadata{
 						KeyId:        aws.String(key1),
-						KeyManager:   aws.String(kms.KeyManagerTypeCustomer),
+						KeyManager:   types.KeyManagerTypeCustomer,
 						CreationDate: aws.Time(now),
 					},
 				},
 				key2: {
-					KeyMetadata: &kms.KeyMetadata{
+					KeyMetadata: &types.KeyMetadata{
 						KeyId:        aws.String(key2),
-						KeyManager:   aws.String(kms.KeyManagerTypeCustomer),
+						KeyManager:   types.KeyManagerTypeCustomer,
 						CreationDate: aws.Time(now.Add(1)),
 					},
 				},
@@ -135,13 +130,12 @@ func TestKMS_GetAll(t *testing.T) {
 				KMSCustomerKeys: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestKMS_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	kck := KmsCustomerKeys{
diff --git a/aws/resources/lambda_layer_test.go b/aws/resources/lambda_layer_test.go
index ebf3abc..bdfc075 100644
--- a/aws/resources/lambda_layer_test.go
+++ b/aws/resources/lambda_layer_test.go
@@ -6,33 +6,33 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/lambda"
-	"github.com/aws/aws-sdk-go/service/lambda/lambdaiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/lambda"
+	"github.com/aws/aws-sdk-go-v2/service/lambda/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedLambdaLayer struct {
-	lambdaiface.LambdaAPI
+	LambdaLayersAPI
+	DeleteLayerVersionOutput lambda.DeleteLayerVersionOutput
 	ListLayersOutput         lambda.ListLayersOutput
 	ListLayerVersionsOutput  lambda.ListLayerVersionsOutput
-	DeleteLayerVersionOutput lambda.DeleteLayerVersionOutput
 }
 
-func (m mockedLambdaLayer) ListLayersPagesWithContext(_ aws.Context, input *lambda.ListLayersInput, fn func(*lambda.ListLayersOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListLayersOutput, true)
-	return nil
+func (m mockedLambdaLayer) DeleteLayerVersion(ctx context.Context, params *lambda.DeleteLayerVersionInput, optFns ...func(*lambda.Options)) (*lambda.DeleteLayerVersionOutput, error) {
+	return &m.DeleteLayerVersionOutput, nil
 }
 
-func (m mockedLambdaLayer) ListLayerVersionsPagesWithContext(_ aws.Context, input *lambda.ListLayerVersionsInput, fn func(*lambda.ListLayerVersionsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListLayerVersionsOutput, true)
-	return nil
+func (m mockedLambdaLayer) ListLayers(ctx context.Context, params *lambda.ListLayersInput, optFns ...func(*lambda.Options)) (*lambda.ListLayersOutput, error) {
+	return &m.ListLayersOutput, nil
 }
 
-func TestLambdaLayer_GetAll(t *testing.T) {
+func (m mockedLambdaLayer) ListLayerVersions(ctx context.Context, params *lambda.ListLayerVersionsInput, optFns ...func(*lambda.Options)) (*lambda.ListLayerVersionsOutput, error) {
+	return &m.ListLayerVersionsOutput, nil
+}
 
+func TestLambdaLayer_GetAll(t *testing.T) {
 	t.Parallel()
 
 	testName1 := "test-lambda-layer1"
@@ -50,25 +50,25 @@ func TestLambdaLayer_GetAll(t *testing.T) {
 	ll := LambdaLayers{
 		Client: mockedLambdaLayer{
 			ListLayersOutput: lambda.ListLayersOutput{
-				Layers: []*lambda.LayersListItem{
+				Layers: []types.LayersListItem{
 					{
 						LayerName: aws.String(testName1),
-						LatestMatchingVersion: &lambda.LayerVersionsListItem{
+						LatestMatchingVersion: &types.LayerVersionsListItem{
 							CreatedDate: aws.String(testTimeStr),
 						},
 					},
 					{
 						LayerName: aws.String(testName2),
-						LatestMatchingVersion: &lambda.LayerVersionsListItem{
+						LatestMatchingVersion: &types.LayerVersionsListItem{
 							CreatedDate: aws.String(testTimeStr),
 						},
 					},
 				},
 			},
 			ListLayerVersionsOutput: lambda.ListLayerVersionsOutput{
-				LayerVersions: []*lambda.LayerVersionsListItem{
+				LayerVersions: []types.LayerVersionsListItem{
 					{
-						Version: &testName1Version1,
+						Version: testName1Version1,
 					},
 				},
 			},
@@ -106,13 +106,12 @@ func TestLambdaLayer_GetAll(t *testing.T) {
 				LambdaLayer: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestLambdaLayer_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	ll := LambdaLayers{
diff --git a/aws/resources/lambda_test.go b/aws/resources/lambda_test.go
index 1444402..38d9743 100644
--- a/aws/resources/lambda_test.go
+++ b/aws/resources/lambda_test.go
@@ -6,31 +6,28 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/lambda"
-	"github.com/aws/aws-sdk-go/service/lambda/lambdaiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/lambda"
+	"github.com/aws/aws-sdk-go-v2/service/lambda/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedLambda struct {
-	lambdaiface.LambdaAPI
-	ListFunctionsOutput  lambda.ListFunctionsOutput
+	LambdaFunctionsAPI
 	DeleteFunctionOutput lambda.DeleteFunctionOutput
+	ListFunctionsOutput  lambda.ListFunctionsOutput
 }
 
-func (m mockedLambda) ListFunctionsPagesWithContext(_ aws.Context, input *lambda.ListFunctionsInput, fn func(*lambda.ListFunctionsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListFunctionsOutput, true)
-	return nil
+func (m mockedLambda) DeleteFunction(ctx context.Context, params *lambda.DeleteFunctionInput, optFns ...func(*lambda.Options)) (*lambda.DeleteFunctionOutput, error) {
+	return &m.DeleteFunctionOutput, nil
 }
 
-func (m mockedLambda) DeleteFunctionWithContext(_ aws.Context, input *lambda.DeleteFunctionInput, _ ...request.Option) (*lambda.DeleteFunctionOutput, error) {
-	return &m.DeleteFunctionOutput, nil
+func (m mockedLambda) ListFunctions(ctx context.Context, params *lambda.ListFunctionsInput, optFns ...func(*lambda.Options)) (*lambda.ListFunctionsOutput, error) {
+	return &m.ListFunctionsOutput, nil
 }
 
 func TestLambdaFunction_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-lambda-function1"
@@ -45,7 +42,7 @@ func TestLambdaFunction_GetAll(t *testing.T) {
 	lf := LambdaFunctions{
 		Client: mockedLambda{
 			ListFunctionsOutput: lambda.ListFunctionsOutput{
-				Functions: []*lambda.FunctionConfiguration{
+				Functions: []types.FunctionConfiguration{
 					{
 						FunctionName: aws.String(testName1),
 						LastModified: aws.String(testTimeStr),
@@ -90,13 +87,12 @@ func TestLambdaFunction_GetAll(t *testing.T) {
 				LambdaFunction: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestLambdaFunction_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	lf := LambdaFunctions{
diff --git a/aws/resources/macie_test.go b/aws/resources/macie_test.go
index 8b81d11..5707080 100644
--- a/aws/resources/macie_test.go
+++ b/aws/resources/macie_test.go
@@ -5,19 +5,17 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/macie2"
-	"github.com/aws/aws-sdk-go/service/macie2/macie2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/macie2"
+	"github.com/aws/aws-sdk-go-v2/service/macie2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedMacie struct {
-	macie2iface.Macie2API
+	MacieMemberAPI
 	GetMacieSessionOutput                      macie2.GetMacieSessionOutput
-	ListMacieMembersOutput                     macie2.ListMembersOutput
+	ListMembersOutput                          macie2.ListMembersOutput
 	DisassociateMemberOutput                   macie2.DisassociateMemberOutput
 	DeleteMemberOutput                         macie2.DeleteMemberOutput
 	GetAdministratorAccountOutput              macie2.GetAdministratorAccountOutput
@@ -25,44 +23,43 @@ type mockedMacie struct {
 	DisableMacieOutput                         macie2.DisableMacieOutput
 }
 
-func (m mockedMacie) GetMacieSessionWithContext(_ aws.Context, input *macie2.GetMacieSessionInput, _ ...request.Option) (*macie2.GetMacieSessionOutput, error) {
+func (m mockedMacie) GetMacieSession(ctx context.Context, params *macie2.GetMacieSessionInput, optFns ...func(*macie2.Options)) (*macie2.GetMacieSessionOutput, error) {
 	return &m.GetMacieSessionOutput, nil
 }
 
-func (m mockedMacie) ListMembersWithContext(_ aws.Context, _ *macie2.ListMembersInput, _ ...request.Option) (*macie2.ListMembersOutput, error) {
-	return &m.ListMacieMembersOutput, nil
+func (m mockedMacie) ListMembers(ctx context.Context, params *macie2.ListMembersInput, optFns ...func(*macie2.Options)) (*macie2.ListMembersOutput, error) {
+	return &m.ListMembersOutput, nil
 }
 
-func (m mockedMacie) DisassociateMemberWithContext(_ aws.Context, _ *macie2.DisassociateMemberInput, _ ...request.Option) (*macie2.DisassociateMemberOutput, error) {
+func (m mockedMacie) DisassociateMember(ctx context.Context, params *macie2.DisassociateMemberInput, optFns ...func(*macie2.Options)) (*macie2.DisassociateMemberOutput, error) {
 	return &m.DisassociateMemberOutput, nil
 }
 
-func (m mockedMacie) DeleteMemberWithContext(_ aws.Context, _ *macie2.DeleteMemberInput, _ ...request.Option) (*macie2.DeleteMemberOutput, error) {
+func (m mockedMacie) DeleteMember(ctx context.Context, params *macie2.DeleteMemberInput, optFns ...func(*macie2.Options)) (*macie2.DeleteMemberOutput, error) {
 	return &m.DeleteMemberOutput, nil
 }
 
-func (m mockedMacie) GetAdministratorAccountWithContext(_ aws.Context, _ *macie2.GetAdministratorAccountInput, _ ...request.Option) (*macie2.GetAdministratorAccountOutput, error) {
+func (m mockedMacie) GetAdministratorAccount(ctx context.Context, params *macie2.GetAdministratorAccountInput, optFns ...func(*macie2.Options)) (*macie2.GetAdministratorAccountOutput, error) {
 	return &m.GetAdministratorAccountOutput, nil
 }
 
-func (m mockedMacie) DisassociateFromAdministratorAccountWithContext(_ aws.Context, _ *macie2.DisassociateFromAdministratorAccountInput, _ ...request.Option) (*macie2.DisassociateFromAdministratorAccountOutput, error) {
+func (m mockedMacie) DisassociateFromAdministratorAccount(ctx context.Context, params *macie2.DisassociateFromAdministratorAccountInput, optFns ...func(*macie2.Options)) (*macie2.DisassociateFromAdministratorAccountOutput, error) {
 	return &m.DisassociateFromAdministratorAccountOutput, nil
 }
 
-func (m mockedMacie) DisableMacieWithContext(_ aws.Context, _ *macie2.DisableMacieInput, _ ...request.Option) (*macie2.DisableMacieOutput, error) {
+func (m mockedMacie) DisableMacie(ctx context.Context, params *macie2.DisableMacieInput, optFns ...func(*macie2.Options)) (*macie2.DisableMacieOutput, error) {
 	return &m.DisableMacieOutput, nil
 }
 
 func TestMacie_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	now := time.Now()
 	mm := MacieMember{
 		Client: mockedMacie{
 			GetMacieSessionOutput: macie2.GetMacieSessionOutput{
-				Status:    awsgo.String("ENABLED"),
-				CreatedAt: awsgo.Time(now),
+				Status:    types.MacieStatusEnabled,
+				CreatedAt: aws.Time(now),
 			},
 		},
 	}
@@ -72,15 +69,14 @@ func TestMacie_GetAll(t *testing.T) {
 }
 
 func TestMacie_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	mm := MacieMember{
 		Client: mockedMacie{
-			ListMacieMembersOutput: macie2.ListMembersOutput{
-				Members: []*macie2.Member{
+			ListMembersOutput: macie2.ListMembersOutput{
+				Members: []types.Member{
 					{
-						AccountId: awsgo.String("123456789012"),
+						AccountId: aws.String("123456789012"),
 					},
 				},
 			},
@@ -88,8 +84,8 @@ func TestMacie_NukeAll(t *testing.T) {
 			DisassociateMemberOutput: macie2.DisassociateMemberOutput{},
 			DeleteMemberOutput:       macie2.DeleteMemberOutput{},
 			GetAdministratorAccountOutput: macie2.GetAdministratorAccountOutput{
-				Administrator: &macie2.Invitation{
-					AccountId: awsgo.String("123456789012"),
+				Administrator: &types.Invitation{
+					AccountId: aws.String("123456789012"),
 				},
 			},
 			DisassociateFromAdministratorAccountOutput: macie2.DisassociateFromAdministratorAccountOutput{},