Repository: gruntwork-io/cloud-nuke
Pull request #772 (2024-10-20 11:44:06)

Migrate to aws sdk v2 part 1
## Description

port the below resources to AWS SDKv2 (part of work for #770
- APIGWv1
- APIGWv2
- ASG
- access_analyzer
- acm
- acmpca
- ami
- appRunner
- backupvault
- cloudTrail
- cloudWatchalarm
- cloudWatchdashboard
- cloudWatchlogGroup
- codeDeployApplication
- configrecorder
- configservice
- dataSynclocation
- dataSynctask
- dynamodb


## 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)

<!-- One-line description of the PR that can be included in the final release notes. -->
Updated APIGWv1, APIGWv2, ASG, access_analyzer, acm, acmpca, ami, appRunner, backupvault, cloudTrail, cloudWatchalarm, cloudWatchdashboard, cloudWatchlogGroup, codeDeployApplication, configrecorder, configservice, dataSynclocation, dataSynctask, dynamodb to AWS SDK v2.

### Migration Guide

n/a


james03160927: Triggered tests for this change. 
wakeful: rebase to remove conflicts.
james03160927: Nice. LGTM. 

Patch:
diff --git a/aws/resources/access_analyzer.go b/aws/resources/access_analyzer.go
index ee12609..fb75301 100644
--- a/aws/resources/access_analyzer.go
+++ b/aws/resources/access_analyzer.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"sync"
 
-	"github.com/aws/aws-sdk-go/service/accessanalyzer"
+	"github.com/aws/aws-sdk-go-v2/service/accessanalyzer"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/go-commons/errors"
@@ -12,23 +12,25 @@ import (
 )
 
 func (analyzer *AccessAnalyzer) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	allAnalyzers := []*string{}
-	err := analyzer.Client.ListAnalyzersPagesWithContext(
-		analyzer.Context,
-		&accessanalyzer.ListAnalyzersInput{},
-		func(page *accessanalyzer.ListAnalyzersOutput, lastPage bool) bool {
-			for _, analyzer := range page.Analyzers {
-				if configObj.AccessAnalyzer.ShouldInclude(config.ResourceValue{
-					Time: analyzer.CreatedAt,
-					Name: analyzer.Name,
-				}) {
-					allAnalyzers = append(allAnalyzers, analyzer.Name)
-				}
+	var allAnalyzers []*string
+	paginator := accessanalyzer.NewListAnalyzersPaginator(analyzer.Client, &accessanalyzer.ListAnalyzersInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, check := range page.Analyzers {
+			if configObj.AccessAnalyzer.ShouldInclude(config.ResourceValue{
+				Time: check.CreatedAt,
+				Name: check.Name,
+			}) {
+				allAnalyzers = append(allAnalyzers, check.Name)
 			}
-			return !lastPage
-		},
-	)
-	return allAnalyzers, errors.WithStackTrace(err)
+		}
+	}
+
+	return allAnalyzers, nil
 }
 
 func (analyzer *AccessAnalyzer) nukeAll(names []*string) error {
@@ -76,7 +78,7 @@ func (analyzer *AccessAnalyzer) deleteAccessAnalyzerAsync(wg *sync.WaitGroup, er
 	defer wg.Done()
 
 	input := &accessanalyzer.DeleteAnalyzerInput{AnalyzerName: analyzerName}
-	_, err := analyzer.Client.DeleteAnalyzerWithContext(
+	_, err := analyzer.Client.DeleteAnalyzer(
 		analyzer.Context, input,
 	)
 	errChan <- err
diff --git a/aws/resources/access_analyzer_types.go b/aws/resources/access_analyzer_types.go
index f54452e..9ec4d4f 100644
--- a/aws/resources/access_analyzer_types.go
+++ b/aws/resources/access_analyzer_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/accessanalyzer"
-	"github.com/aws/aws-sdk-go/service/accessanalyzer/accessanalyzeriface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/accessanalyzer"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type AccessAnalyzerAPI interface {
+	DeleteAnalyzer(ctx context.Context, params *accessanalyzer.DeleteAnalyzerInput, optFns ...func(*accessanalyzer.Options)) (*accessanalyzer.DeleteAnalyzerOutput, error)
+	ListAnalyzers(context.Context, *accessanalyzer.ListAnalyzersInput, ...func(*accessanalyzer.Options)) (*accessanalyzer.ListAnalyzersOutput, error)
+}
+
 // AccessAnalyzer - represents all AWS secrets manager secrets that should be deleted.
 type AccessAnalyzer struct {
 	BaseAwsResource
-	Client        accessanalyzeriface.AccessAnalyzerAPI
+	Client        AccessAnalyzerAPI
 	Region        string
 	AnalyzerNames []string
 }
 
-func (analyzer *AccessAnalyzer) Init(session *session.Session) {
-	analyzer.Client = accessanalyzer.New(session)
+func (analyzer *AccessAnalyzer) InitV2(cfg aws.Config) {
+	analyzer.Client = accessanalyzer.NewFromConfig(cfg)
 }
 
+func (analyzer *AccessAnalyzer) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (analyzer *AccessAnalyzer) ResourceName() string {
 	return "accessanalyzer"
@@ -40,7 +45,7 @@ func (analyzer *AccessAnalyzer) MaxBatchSize() int {
 	return 10
 }
 
-// To get the resource configuration
+// GetAndSetResourceConfig To get the resource configuration
 func (analyzer *AccessAnalyzer) GetAndSetResourceConfig(configObj config.Config) config.ResourceType {
 	return configObj.AccessAnalyzer
 }
@@ -51,13 +56,13 @@ func (analyzer *AccessAnalyzer) GetAndSetIdentifiers(c context.Context, configOb
 		return nil, err
 	}
 
-	analyzer.AnalyzerNames = awsgo.StringValueSlice(identifiers)
+	analyzer.AnalyzerNames = aws.ToStringSlice(identifiers)
 	return analyzer.AnalyzerNames, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (analyzer *AccessAnalyzer) Nuke(identifiers []string) error {
-	if err := analyzer.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := analyzer.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/acm.go b/aws/resources/acm.go
index 53df12b..33e76e7 100644
--- a/aws/resources/acm.go
+++ b/aws/resources/acm.go
@@ -4,7 +4,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/service/acm"
+	"github.com/aws/aws-sdk-go-v2/service/acm"
+	"github.com/aws/aws-sdk-go-v2/service/acm/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -13,40 +14,29 @@ import (
 
 // Returns a list of strings of ACM ARNs
 func (a *ACM) getAll(c context.Context, configObj config.Config) ([]*string, error) {
+	var acmArns []*string
+	paginator := acm.NewListCertificatesPaginator(a.Client, &acm.ListCertificatesInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
 
-	params := &acm.ListCertificatesInput{}
-
-	acmArns := []*string{}
-	err := a.Client.ListCertificatesPagesWithContext(a.Context, params,
-		func(page *acm.ListCertificatesOutput, lastPage bool) bool {
-			for i := range page.CertificateSummaryList {
-				logging.Debug(fmt.Sprintf("Found ACM %s with domain name %s",
-					*page.CertificateSummaryList[i].CertificateArn, *page.CertificateSummaryList[i].DomainName))
-				if a.shouldInclude(page.CertificateSummaryList[i], configObj) {
-					logging.Debug(fmt.Sprintf(
-						"Including ACM %s", *page.CertificateSummaryList[i].CertificateArn))
-					acmArns = append(acmArns, page.CertificateSummaryList[i].CertificateArn)
-				} else {
-					logging.Debug(fmt.Sprintf(
-						"Skipping ACM %s", *page.CertificateSummaryList[i].CertificateArn))
-				}
+		for _, cert := range page.CertificateSummaryList {
+			logging.Debug(fmt.Sprintf("Found ACM %s with domain name %s", *cert.CertificateArn, *cert.DomainName))
+			if a.shouldInclude(cert, configObj) {
+				logging.Debug(fmt.Sprintf("Including ACM %s", *cert.CertificateArn))
+				acmArns = append(acmArns, cert.CertificateArn)
+			} else {
+				logging.Debug(fmt.Sprintf("Skipping ACM %s", *cert.CertificateArn))
 			}
-
-			return !lastPage
-		},
-	)
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
+		}
 	}
 
 	return acmArns, nil
 }
 
-func (a *ACM) shouldInclude(acm *acm.CertificateSummary, configObj config.Config) bool {
-	if acm == nil {
-		return false
-	}
-
+func (a *ACM) shouldInclude(acm types.CertificateSummary, configObj config.Config) bool {
 	if acm.InUse != nil && *acm.InUse {
 		logging.Debug(fmt.Sprintf("ACM %s is in use", *acm.CertificateArn))
 		return false
@@ -69,14 +59,13 @@ func (a *ACM) nukeAll(arns []*string) error {
 	}
 
 	logging.Debugf("Deleting all ACMs in region %s", a.Region)
-
 	deletedCount := 0
 	for _, acmArn := range arns {
 		params := &acm.DeleteCertificateInput{
 			CertificateArn: acmArn,
 		}
 
-		_, err := a.Client.DeleteCertificateWithContext(a.Context, params)
+		_, err := a.Client.DeleteCertificate(a.Context, params)
 		if err != nil {
 			logging.Debugf("[Failed] %s", err)
 		} else {
diff --git a/aws/resources/acm_types.go b/aws/resources/acm_types.go
index c053329..9d14997 100644
--- a/aws/resources/acm_types.go
+++ b/aws/resources/acm_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/acm"
-	"github.com/aws/aws-sdk-go/service/acm/acmiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/acm"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// ACMPA - represents all ACMPA
+type ACMServiceAPI interface {
+	DeleteCertificate(ctx context.Context, params *acm.DeleteCertificateInput, optFns ...func(*acm.Options)) (*acm.DeleteCertificateOutput, error)
+	ListCertificates(ctx context.Context, params *acm.ListCertificatesInput, optFns ...func(*acm.Options)) (*acm.ListCertificatesOutput, error)
+}
+
+// ACM - represents all ACM
 type ACM struct {
 	BaseAwsResource
-	Client acmiface.ACMAPI
+	Client ACMServiceAPI
 	Region string
 	ARNs   []string
 }
 
-func (a *ACM) Init(session *session.Session) {
-	a.Client = acm.New(session)
+func (a *ACM) InitV2(cfg aws.Config) {
+	a.Client = acm.NewFromConfig(cfg)
 }
 
+func (a *ACM) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (a *ACM) ResourceName() string {
 	return "acm"
@@ -38,7 +43,7 @@ func (a *ACM) MaxBatchSize() int {
 	return 10
 }
 
-// To get the resource configuration
+// GetAndSetResourceConfig To get the resource configuration
 func (a *ACM) GetAndSetResourceConfig(configObj config.Config) config.ResourceType {
 	return configObj.ACM
 }
@@ -49,13 +54,13 @@ func (a *ACM) GetAndSetIdentifiers(c context.Context, configObj config.Config) (
 		return nil, err
 	}
 
-	a.ARNs = awsgo.StringValueSlice(identifiers)
+	a.ARNs = aws.ToStringSlice(identifiers)
 	return a.ARNs, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (a *ACM) Nuke(arns []string) error {
-	if err := a.nukeAll(awsgo.StringSlice(arns)); err != nil {
+	if err := a.nukeAll(aws.StringSlice(arns)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/acmpca.go b/aws/resources/acmpca.go
index a93bc1d..cb1a804 100644
--- a/aws/resources/acmpca.go
+++ b/aws/resources/acmpca.go
@@ -6,8 +6,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/acmpca"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/acmpca"
+	"github.com/aws/aws-sdk-go-v2/service/acmpca/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -15,34 +16,30 @@ import (
 	"github.com/hashicorp/go-multierror"
 )
 
-// GetAll returns a list of all arns of ACMPCA, which can be deleted.
+// GetAll returns a list of all arn's of ACMPCA, which can be deleted.
 func (ap *ACMPCA) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var arns []*string
-	paginationErr := ap.Client.ListCertificateAuthoritiesPagesWithContext(
-		ap.Context,
-		&acmpca.ListCertificateAuthoritiesInput{},
-		func(p *acmpca.ListCertificateAuthoritiesOutput, lastPage bool) bool {
-			for _, ca := range p.CertificateAuthorities {
-				if ap.shouldInclude(ca, configObj) {
-					arns = append(arns, ca.Arn)
-				}
+
+	paginator := acmpca.NewListCertificateAuthoritiesPaginator(ap.Client, &acmpca.ListCertificateAuthoritiesInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, ca := range page.CertificateAuthorities {
+			if ap.shouldInclude(ca, configObj) {
+				arns = append(arns, ca.Arn)
 			}
-			return !lastPage
-		})
-	if paginationErr != nil {
-		return nil, errors.WithStackTrace(paginationErr)
+		}
 	}
 
 	return arns, nil
 }
 
-func (ap *ACMPCA) shouldInclude(ca *acmpca.CertificateAuthority, configObj config.Config) bool {
-	if ca == nil {
-		return false
-	}
-
-	statusSafe := aws.StringValue(ca.Status)
-	if statusSafe == acmpca.CertificateAuthorityStatusDeleted {
+func (ap *ACMPCA) shouldInclude(ca types.CertificateAuthority, configObj config.Config) bool {
+	statusSafe := ca.Status
+	if statusSafe == types.CertificateAuthorityStatusDeleted {
 		return false
 	}
 
@@ -50,15 +47,15 @@ func (ap *ACMPCA) shouldInclude(ca *acmpca.CertificateAuthority, configObj confi
 	// unless it was never changed and createAt time is used.
 	var referenceTime time.Time
 	if ca.LastStateChangeAt == nil {
-		referenceTime = aws.TimeValue(ca.CreatedAt)
+		referenceTime = aws.ToTime(ca.CreatedAt)
 	} else {
-		referenceTime = aws.TimeValue(ca.LastStateChangeAt)
+		referenceTime = aws.ToTime(ca.LastStateChangeAt)
 	}
 
 	return configObj.ACMPCA.ShouldInclude(config.ResourceValue{Time: &referenceTime})
 }
 
-// nukeAll will delete all ACMPCA, which are given by a list of arns.
+// nukeAll will delete all ACMPCA, which are given by a list of arn's.
 func (ap *ACMPCA) nukeAll(arns []*string) error {
 	if len(arns) == 0 {
 		logging.Debugf("No ACMPCA to nuke in region %s", ap.Region)
@@ -94,7 +91,7 @@ func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *strin
 	defer wg.Done()
 
 	logging.Debugf("Fetching details of CA to be deleted for ACMPCA %s in region %s", *arn, ap.Region)
-	details, detailsErr := ap.Client.DescribeCertificateAuthorityWithContext(
+	details, detailsErr := ap.Client.DescribeCertificateAuthority(
 		ap.Context,
 		&acmpca.DescribeCertificateAuthorityInput{CertificateAuthorityArn: arn})
 	if detailsErr != nil {
@@ -102,26 +99,26 @@ func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *strin
 		return
 	}
 	if details.CertificateAuthority == nil {
-		errChan <- fmt.Errorf("could not find CA %s", aws.StringValue(arn))
+		errChan <- fmt.Errorf("could not find CA %s", aws.ToString(arn))
 		return
 	}
-	if details.CertificateAuthority.Status == nil {
-		errChan <- fmt.Errorf("could not fetch status for CA %s", aws.StringValue(arn))
+	if details.CertificateAuthority.Status == "" {
+		errChan <- fmt.Errorf("could not fetch status for CA %s", aws.ToString(arn))
 		return
 	}
 
 	// find out, whether we have to disable the CA first, prior to deletion.
-	statusSafe := aws.StringValue(details.CertificateAuthority.Status)
-	shouldUpdateStatus := statusSafe != acmpca.CertificateAuthorityStatusCreating &&
-		statusSafe != acmpca.CertificateAuthorityStatusPendingCertificate &&
-		statusSafe != acmpca.CertificateAuthorityStatusDisabled &&
-		statusSafe != acmpca.CertificateAuthorityStatusDeleted
+	statusSafe := details.CertificateAuthority.Status
+	shouldUpdateStatus := statusSafe != types.CertificateAuthorityStatusCreating &&
+		statusSafe != types.CertificateAuthorityStatusPendingCertificate &&
+		statusSafe != types.CertificateAuthorityStatusDisabled &&
+		statusSafe != types.CertificateAuthorityStatusDeleted
 
 	if shouldUpdateStatus {
 		logging.Debugf("Setting status to 'DISABLED' for ACMPCA %s in region %s", *arn, ap.Region)
-		if _, updateStatusErr := ap.Client.UpdateCertificateAuthorityWithContext(ap.Context, &acmpca.UpdateCertificateAuthorityInput{
+		if _, updateStatusErr := ap.Client.UpdateCertificateAuthority(ap.Context, &acmpca.UpdateCertificateAuthorityInput{
 			CertificateAuthorityArn: arn,
-			Status:                  aws.String(acmpca.CertificateAuthorityStatusDisabled),
+			Status:                  types.CertificateAuthorityStatusDisabled,
 		}); updateStatusErr != nil {
 			errChan <- updateStatusErr
 			return
@@ -130,17 +127,17 @@ func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *strin
 		logging.Debugf("Did set status to 'DISABLED' for ACMPCA: %s in region %s", *arn, ap.Region)
 	}
 
-	_, deleteErr := ap.Client.DeleteCertificateAuthorityWithContext(ap.Context, &acmpca.DeleteCertificateAuthorityInput{
+	_, deleteErr := ap.Client.DeleteCertificateAuthority(ap.Context, &acmpca.DeleteCertificateAuthorityInput{
 		CertificateAuthorityArn: arn,
 		// the range is 7 to 30 days.
 		// since cloud-nuke should not be used in production,
 		// we assume that the minimum (7 days) is fine.
-		PermanentDeletionTimeInDays: aws.Int64(7),
+		PermanentDeletionTimeInDays: aws.Int32(7),
 	})
 
 	// Record status of this resource
 	e := report.Entry{
-		Identifier:   aws.StringValue(arn),
+		Identifier:   aws.ToString(arn),
 		ResourceType: "ACM Private CA (ACMPCA)",
 		Error:        deleteErr,
 	}
diff --git a/aws/resources/acmpca_types.go b/aws/resources/acmpca_types.go
index e7cb67b..5d7007b 100644
--- a/aws/resources/acmpca_types.go
+++ b/aws/resources/acmpca_types.go
@@ -3,26 +3,33 @@ 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/acmpca"
-	"github.com/aws/aws-sdk-go/service/acmpca/acmpcaiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/acmpca"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// ACMPA - represents all ACMPA
+type ACMPCAServiceAPI interface {
+	DeleteCertificateAuthority(ctx context.Context, params *acmpca.DeleteCertificateAuthorityInput, optFns ...func(*acmpca.Options)) (*acmpca.DeleteCertificateAuthorityOutput, error)
+	DescribeCertificateAuthority(ctx context.Context, params *acmpca.DescribeCertificateAuthorityInput, optFns ...func(*acmpca.Options)) (*acmpca.DescribeCertificateAuthorityOutput, error)
+	ListCertificateAuthorities(ctx context.Context, params *acmpca.ListCertificateAuthoritiesInput, optFns ...func(*acmpca.Options)) (*acmpca.ListCertificateAuthoritiesOutput, error)
+	UpdateCertificateAuthority(ctx context.Context, params *acmpca.UpdateCertificateAuthorityInput, optFns ...func(*acmpca.Options)) (*acmpca.UpdateCertificateAuthorityOutput, error)
+}
+
+// ACMPCA - represents all ACMPA
 type ACMPCA struct {
 	BaseAwsResource
-	Client acmpcaiface.ACMPCAAPI
+	Client ACMPCAServiceAPI
 	Region string
 	ARNs   []string
 }
 
-func (ap *ACMPCA) Init(session *session.Session) {
-	ap.Client = acmpca.New(session)
+func (ap *ACMPCA) InitV2(cfg aws.Config) {
+	ap.Client = acmpca.NewFromConfig(cfg)
 }
 
+func (ap *ACMPCA) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (ap *ACMPCA) ResourceName() string {
 	return "acmpca"
@@ -47,13 +54,13 @@ func (ap *ACMPCA) GetAndSetIdentifiers(c context.Context, configObj config.Confi
 		return nil, err
 	}
 
-	ap.ARNs = awsgo.StringValueSlice(identifiers)
+	ap.ARNs = aws.ToStringSlice(identifiers)
 	return ap.ARNs, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (ap *ACMPCA) Nuke(arns []string) error {
-	if err := ap.nukeAll(awsgo.StringSlice(arns)); err != nil {
+	if err := ap.nukeAll(aws.StringSlice(arns)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/ami.go b/aws/resources/ami.go
index 9fdcd0f..5dfe1c0 100644
--- a/aws/resources/ami.go
+++ b/aws/resources/ami.go
@@ -4,11 +4,10 @@ import (
 	"context"
 	"strings"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
 	"github.com/gruntwork-io/cloud-nuke/util"
 
-	"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/report"
@@ -17,49 +16,53 @@ import (
 
 // Returns a formatted string of AMI Image ids
 func (ami *AMIs) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	params := &ec2.DescribeImagesInput{
-		Owners: []*string{awsgo.String("self")},
-	}
-
-	output, err := ami.Client.DescribeImagesWithContext(ami.Context, params)
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
-	}
-
 	var imageIds []*string
-	for _, image := range output.Images {
-		createdTime, err := util.ParseTimestamp(image.CreationDate)
+	paginator := ec2.NewDescribeImagesPaginator(ami.Client, &ec2.DescribeImagesInput{
+		Owners: []string{"self"},
+	})
+
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
 		if err != nil {
-			return nil, err
+			return nil, errors.WithStackTrace(err)
 		}
 
-		// Check if the image has a tag that indicates AWS management
-		isAWSManaged := false
-		for _, tag := range image.Tags {
-			if *tag.Key == "aws-managed" && *tag.Value == "true" {
-				isAWSManaged = true
-				break
+		for _, image := range page.Images {
+
+			createdTime, errTimeParse := util.ParseTimestamp(image.CreationDate)
+			if errTimeParse != nil {
+				return nil, errTimeParse
 			}
-		}
 
-		// Skip AWS managed images and images created by AWS Backup
-		if isAWSManaged || strings.HasPrefix(*image.Name, "AwsBackup") {
-			continue
-		}
+			// Check if the image has a tag that indicates AWS management
+			isAWSManaged := false
+			for _, tag := range image.Tags {
+				if *tag.Key == "aws-managed" && *tag.Value == "true" {
+					isAWSManaged = true
+					break
+				}
+			}
+
+			// Skip AWS managed images and images created by AWS Backup
+			if isAWSManaged || strings.HasPrefix(*image.Name, "AwsBackup") {
+				continue
+			}
+
+			if configObj.AMI.ShouldInclude(config.ResourceValue{
+				Name: image.Name,
+				Time: createdTime,
+			}) {
+				imageIds = append(imageIds, image.ImageId)
+			}
 
-		if configObj.AMI.ShouldInclude(config.ResourceValue{
-			Name: image.Name,
-			Time: createdTime,
-		}) {
-			imageIds = append(imageIds, image.ImageId)
 		}
 	}
 
 	// checking the nukable permissions
 	ami.VerifyNukablePermissions(imageIds, func(id *string) error {
-		_, err := ami.Client.DeregisterImageWithContext(ami.Context, &ec2.DeregisterImageInput{
+		_, err := ami.Client.DeregisterImage(ami.Context, &ec2.DeregisterImageInput{
 			ImageId: id,
-			DryRun:  awsgo.Bool(true),
+			DryRun:  aws.Bool(true),
 		})
 		return err
 	})
@@ -79,18 +82,18 @@ func (ami *AMIs) nukeAll(imageIds []*string) error {
 
 	deletedCount := 0
 	for _, imageID := range imageIds {
-		if nukable, reason := ami.IsNukable(awsgo.StringValue(imageID)); !nukable {
-			logging.Debugf("[Skipping] %s nuke because %v", awsgo.StringValue(imageID), reason)
+		if nukable, reason := ami.IsNukable(aws.ToString(imageID)); !nukable {
+			logging.Debugf("[Skipping] %s nuke because %v", aws.ToString(imageID), reason)
 			continue
 		}
 
-		_, err := ami.Client.DeregisterImageWithContext(ami.Context, &ec2.DeregisterImageInput{
+		_, err := ami.Client.DeregisterImage(ami.Context, &ec2.DeregisterImageInput{
 			ImageId: imageID,
 		})
 
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   aws.StringValue(imageID),
+			Identifier:   aws.ToString(imageID),
 			ResourceType: "Amazon Machine Image (AMI)",
 			Error:        err,
 		}
diff --git a/aws/resources/ami_types.go b/aws/resources/ami_types.go
index 6d35307..1a7725e 100644
--- a/aws/resources/ami_types.go
+++ b/aws/resources/ami_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 AMIsAPI interface {
+	DeregisterImage(ctx context.Context, params *ec2.DeregisterImageInput, optFns ...func(*ec2.Options)) (*ec2.DeregisterImageOutput, error)
+	DescribeImages(ctx context.Context, params *ec2.DescribeImagesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error)
+}
+
 // AMIs - represents all user owned AMIs
 type AMIs struct {
 	BaseAwsResource
-	Client   ec2iface.EC2API
+	Client   AMIsAPI
 	Region   string
 	ImageIds []string
 }
 
-func (ami *AMIs) Init(session *session.Session) {
-	ami.Client = ec2.New(session)
+func (ami *AMIs) InitV2(cfg aws.Config) {
+	ami.Client = ec2.NewFromConfig(cfg)
 }
 
+func (ami *AMIs) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (ami *AMIs) ResourceName() string {
 	return "ami"
@@ -48,13 +53,13 @@ func (ami *AMIs) GetAndSetIdentifiers(c context.Context, configObj config.Config
 		return nil, err
 	}
 
-	ami.ImageIds = awsgo.StringValueSlice(identifiers)
+	ami.ImageIds = aws.ToStringSlice(identifiers)
 	return ami.ImageIds, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (ami *AMIs) Nuke(identifiers []string) error {
-	if err := ami.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := ami.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/apigateway.go b/aws/resources/apigateway.go
index 3600b12..c636b93 100644
--- a/aws/resources/apigateway.go
+++ b/aws/resources/apigateway.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/apigateway"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apigateway"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -14,7 +14,7 @@ import (
 )
 
 func (gateway *ApiGateway) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	result, err := gateway.Client.GetRestApisWithContext(gateway.Context, &apigateway.GetRestApisInput{})
+	result, err := gateway.Client.GetRestApis(c, &apigateway.GetRestApisInput{})
 	if err != nil {
 		return []*string{}, errors.WithStackTrace(err)
 	}
@@ -73,12 +73,12 @@ func (gateway *ApiGateway) getAttachedStageClientCerts(apigwID *string) ([]*stri
 	var clientCerts []*string
 
 	// remove the client certificate attached with the stages
-	stages, err := gateway.Client.GetStagesWithContext(gateway.Context, &apigateway.GetStagesInput{
+	stages, err := gateway.Client.GetStages(gateway.Context, &apigateway.GetStagesInput{
 		RestApiId: apigwID,
 	})
 
 	if err != nil {
-		return clientCerts, err
+		return nil, err
 	}
 	// get the stages attached client certificates
 	for _, stage := range stages.Item {
@@ -95,7 +95,7 @@ func (gateway *ApiGateway) removeAttachedClientCertificates(clientCerts []*strin
 
 	for _, cert := range clientCerts {
 		logging.Debugf("Deleting Client Certificate %s", *cert)
-		_, err := gateway.Client.DeleteClientCertificateWithContext(gateway.Context, &apigateway.DeleteClientCertificateInput{
+		_, err := gateway.Client.DeleteClientCertificate(gateway.Context, &apigateway.DeleteClientCertificateInput{
 			ClientCertificateId: cert,
 		})
 		if err != nil {
@@ -113,7 +113,7 @@ func (gateway *ApiGateway) nukeAsync(
 	clientCerts, err := gateway.getAttachedStageClientCerts(apigwID)
 
 	input := &apigateway.DeleteRestApiInput{RestApiId: apigwID}
-	_, err = gateway.Client.DeleteRestApiWithContext(gateway.Context, input)
+	_, err = gateway.Client.DeleteRestApi(gateway.Context, input)
 
 	// When the rest-api endpoint delete successfully, then remove attached client certs
 	if err == nil {
@@ -133,10 +133,10 @@ func (gateway *ApiGateway) nukeAsync(
 
 	if err == nil {
 		logging.Debugf("["+
-			"OK] API Gateway (v1) %s deleted in %s", aws.StringValue(apigwID), gateway.Region)
+			"OK] API Gateway (v1) %s deleted in %s", aws.ToString(apigwID), gateway.Region)
 		return
 	}
 
 	logging.Debugf(
-		"[Failed] Error deleting API Gateway (v1) %s in %s", aws.StringValue(apigwID), gateway.Region)
+		"[Failed] Error deleting API Gateway (v1) %s in %s", aws.ToString(apigwID), gateway.Region)
 }
diff --git a/aws/resources/apigateway_types.go b/aws/resources/apigateway_types.go
index 5a0054c..5539756 100644
--- a/aws/resources/apigateway_types.go
+++ b/aws/resources/apigateway_types.go
@@ -3,25 +3,32 @@ 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/apigateway"
-	"github.com/aws/aws-sdk-go/service/apigateway/apigatewayiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apigateway"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type ApiGatewayServiceAPI interface {
+	GetRestApis(ctx context.Context, params *apigateway.GetRestApisInput, optFns ...func(*apigateway.Options)) (*apigateway.GetRestApisOutput, error)
+	GetStages(ctx context.Context, params *apigateway.GetStagesInput, optFns ...func(*apigateway.Options)) (*apigateway.GetStagesOutput, error)
+	DeleteClientCertificate(ctx context.Context, params *apigateway.DeleteClientCertificateInput, optFns ...func(*apigateway.Options)) (*apigateway.DeleteClientCertificateOutput, error)
+	DeleteRestApi(ctx context.Context, params *apigateway.DeleteRestApiInput, optFns ...func(*apigateway.Options)) (*apigateway.DeleteRestApiOutput, error)
+}
+
 type ApiGateway struct {
 	BaseAwsResource
-	Client apigatewayiface.APIGatewayAPI
+	Client ApiGatewayServiceAPI
 	Region string
 	Ids    []string
 }
 
-func (gateway *ApiGateway) Init(session *session.Session) {
-	gateway.Client = apigateway.New(session)
+func (gateway *ApiGateway) InitV2(cfg aws.Config) {
+	gateway.Client = apigateway.NewFromConfig(cfg)
 }
 
+func (gateway *ApiGateway) IsUsingV2() bool { return true }
+
 func (gateway *ApiGateway) ResourceName() string {
 	return "apigateway"
 }
@@ -44,12 +51,12 @@ func (gateway *ApiGateway) GetAndSetIdentifiers(c context.Context, configObj con
 		return nil, err
 	}
 
-	gateway.Ids = awsgo.StringValueSlice(identifiers)
+	gateway.Ids = aws.ToStringSlice(identifiers)
 	return gateway.Ids, nil
 }
 
 func (gateway *ApiGateway) Nuke(identifiers []string) error {
-	if err := gateway.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := gateway.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/apigatewayv2.go b/aws/resources/apigatewayv2.go
index a2e5662..9f71356 100644
--- a/aws/resources/apigatewayv2.go
+++ b/aws/resources/apigatewayv2.go
@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/apigatewayv2"
-	"github.com/aws/aws-sdk-go/service/apigatewayv2/apigatewayv2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apigatewayv2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -15,13 +14,13 @@ import (
 	"github.com/hashicorp/go-multierror"
 )
 
-func (gw *ApiGatewayV2) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	output, err := gw.Client.GetApisWithContext(gw.Context, &apigatewayv2.GetApisInput{})
+func (gw *ApiGatewayV2) getAll(ctx context.Context, configObj config.Config) ([]*string, error) {
+	output, err := gw.Client.GetApis(gw.Context, &apigatewayv2.GetApisInput{})
 	if err != nil {
 		return []*string{}, errors.WithStackTrace(err)
 	}
 
-	Ids := []*string{}
+	var Ids []*string
 	for _, restapi := range output.Items {
 		if configObj.APIGatewayV2.ShouldInclude(config.ResourceValue{
 			Time: restapi.CreatedDate,
@@ -45,7 +44,7 @@ func (gw *ApiGatewayV2) nukeAll(identifiers []*string) error {
 		return TooManyApiGatewayV2Err{}
 	}
 
-	err := deleteAssociatedApiMappings(gw.Client, identifiers)
+	err := deleteAssociatedApiMappings(gw.Context, gw.Client, identifiers)
 	if err != nil {
 		return errors.WithStackTrace(err)
 	}
@@ -78,7 +77,7 @@ func (gw *ApiGatewayV2) deleteAsync(wg *sync.WaitGroup, errChan chan error, apiI
 	defer wg.Done()
 
 	input := &apigatewayv2.DeleteApiInput{ApiId: apiId}
-	_, err := gw.Client.DeleteApiWithContext(gw.Context, input)
+	_, err := gw.Client.DeleteApi(gw.Context, input)
 	errChan <- err
 
 	// Record status of this resource
@@ -90,21 +89,20 @@ func (gw *ApiGatewayV2) deleteAsync(wg *sync.WaitGroup, errChan chan error, apiI
 	report.Record(e)
 
 	if err == nil {
-		logging.Debug(fmt.Sprintf("Successfully deleted API Gateway (v2) %s in %s", aws.StringValue(apiId), gw.Region))
+		logging.Debug(fmt.Sprintf("Successfully deleted API Gateway (v2) %s in %s", aws.ToString(apiId), gw.Region))
 	} else {
-		logging.Debug(fmt.Sprintf("Failed to delete API Gateway (v2) %s in %s", aws.StringValue(apiId), gw.Region))
+		logging.Debug(fmt.Sprintf("Failed to delete API Gateway (v2) %s in %s", aws.ToString(apiId), gw.Region))
 	}
 }
 
-func deleteAssociatedApiMappings(
-	client apigatewayv2iface.ApiGatewayV2API, identifiers []*string) error {
+func deleteAssociatedApiMappings(ctx context.Context, client ApiGatewayV2API, identifiers []*string) error {
 	// Convert identifiers to map to check if identifier is in list
 	identifierMap := make(map[string]bool)
 	for _, identifier := range identifiers {
 		identifierMap[*identifier] = true
 	}
 
-	domainNames, err := client.GetDomainNames(&apigatewayv2.GetDomainNamesInput{})
+	domainNames, err := client.GetDomainNames(ctx, &apigatewayv2.GetDomainNamesInput{})
 	if err != nil {
 		logging.Debug(fmt.Sprintf("Failed to get domain names: %s", err))
 		return errors.WithStackTrace(err)
@@ -112,7 +110,7 @@ func deleteAssociatedApiMappings(
 
 	logging.Debug(fmt.Sprintf("Found %d domain names", len(domainNames.Items)))
 	for _, domainName := range domainNames.Items {
-		apiMappings, err := client.GetApiMappings(&apigatewayv2.GetApiMappingsInput{
+		apiMappings, err := client.GetApiMappings(ctx, &apigatewayv2.GetApiMappingsInput{
 			DomainName: domainName.DomainName,
 		})
 		if err != nil {
@@ -125,7 +123,7 @@ func deleteAssociatedApiMappings(
 				continue
 			}
 
-			_, err := client.DeleteApiMapping(&apigatewayv2.DeleteApiMappingInput{
+			_, err := client.DeleteApiMapping(ctx, &apigatewayv2.DeleteApiMappingInput{
 				ApiMappingId: apiMapping.ApiMappingId,
 				DomainName:   domainName.DomainName,
 			})
diff --git a/aws/resources/apigatewayv2_types.go b/aws/resources/apigatewayv2_types.go
index ad56131..371c37a 100644
--- a/aws/resources/apigatewayv2_types.go
+++ b/aws/resources/apigatewayv2_types.go
@@ -3,25 +3,33 @@ 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/apigatewayv2"
-	"github.com/aws/aws-sdk-go/service/apigatewayv2/apigatewayv2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apigatewayv2"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type ApiGatewayV2API interface {
+	GetApis(ctx context.Context, params *apigatewayv2.GetApisInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.GetApisOutput, error)
+	GetDomainNames(ctx context.Context, params *apigatewayv2.GetDomainNamesInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.GetDomainNamesOutput, error)
+	GetApiMappings(ctx context.Context, params *apigatewayv2.GetApiMappingsInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.GetApiMappingsOutput, error)
+	DeleteApi(ctx context.Context, params *apigatewayv2.DeleteApiInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.DeleteApiOutput, error)
+	DeleteApiMapping(ctx context.Context, params *apigatewayv2.DeleteApiMappingInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.DeleteApiMappingOutput, error)
+}
+
 type ApiGatewayV2 struct {
 	BaseAwsResource
-	Client apigatewayv2iface.ApiGatewayV2API
+	Client ApiGatewayV2API
 	Region string
 	Ids    []string
 }
 
-func (gw *ApiGatewayV2) Init(session *session.Session) {
-	gw.Client = apigatewayv2.New(session)
+func (gw *ApiGatewayV2) InitV2(cfg aws.Config) {
+	gw.Client = apigatewayv2.NewFromConfig(cfg)
 }
 
+func (gw *ApiGatewayV2) IsUsingV2() bool { return true }
+
 func (gw *ApiGatewayV2) ResourceName() string {
 	return "apigatewayv2"
 }
@@ -44,12 +52,12 @@ func (gw *ApiGatewayV2) GetAndSetIdentifiers(c context.Context, configObj config
 		return nil, err
 	}
 
-	gw.Ids = awsgo.StringValueSlice(identifiers)
+	gw.Ids = aws.ToStringSlice(identifiers)
 	return gw.Ids, nil
 }
 
 func (gw *ApiGatewayV2) Nuke(identifiers []string) error {
-	if err := gw.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := gw.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/apprunner_service.go b/aws/resources/apprunner_service.go
index 6d21acb..a074a43 100644
--- a/aws/resources/apprunner_service.go
+++ b/aws/resources/apprunner_service.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/apprunner"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apprunner"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -23,7 +23,7 @@ func (a *AppRunnerService) nukeAll(identifiers []*string) error {
 	for _, identifier := range identifiers {
 		logging.Debugf("[App Runner Service] Deleting App Runner Service %s in region %s", *identifier, a.Region)
 
-		_, err := a.Client.DeleteServiceWithContext(a.Context, &apprunner.DeleteServiceInput{
+		_, err := a.Client.DeleteService(a.Context, &apprunner.DeleteServiceInput{
 			ServiceArn: identifier,
 		})
 		if err != nil {
@@ -34,7 +34,7 @@ func (a *AppRunnerService) nukeAll(identifiers []*string) error {
 		}
 
 		e := report.Entry{
-			Identifier:   aws.StringValue(identifier),
+			Identifier:   aws.ToString(identifier),
 			ResourceType: a.ResourceName(),
 			Error:        err,
 		}
@@ -47,7 +47,16 @@ func (a *AppRunnerService) nukeAll(identifiers []*string) error {
 
 func (a *AppRunnerService) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var identifiers []*string
-	paginator := func(output *apprunner.ListServicesOutput, lastPage bool) bool {
+	paginator := apprunner.NewListServicesPaginator(a.Client, &apprunner.ListServicesInput{
+		MaxResults: aws.Int32(19),
+	})
+	for paginator.HasMorePages() {
+		output, err := paginator.NextPage(c)
+		if err != nil {
+			logging.Debugf("[App Runner Service] Failed to list app runner services: %s", err)
+			return nil, errors.WithStackTrace(err)
+		}
+
 		for _, service := range output.ServiceSummaryList {
 			if configObj.AppRunnerService.ShouldInclude(config.ResourceValue{
 				Name: service.ServiceName,
@@ -56,16 +65,6 @@ func (a *AppRunnerService) getAll(c context.Context, configObj config.Config) ([
 				identifiers = append(identifiers, service.ServiceArn)
 			}
 		}
-		return !lastPage
-	}
-
-	param := &apprunner.ListServicesInput{
-		MaxResults: aws.Int64(19),
-	}
-
-	if err := a.Client.ListServicesPagesWithContext(c, param, paginator); err != nil {
-		logging.Debugf("[App Runner Service] Failed to list app runner services: %s", err)
-		return nil, errors.WithStackTrace(err)
 	}
 
 	return identifiers, nil
diff --git a/aws/resources/apprunner_service_types.go b/aws/resources/apprunner_service_types.go
index 8c9e43d..4b9496b 100644
--- a/aws/resources/apprunner_service_types.go
+++ b/aws/resources/apprunner_service_types.go
@@ -3,17 +3,20 @@ 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/apprunner"
-	"github.com/aws/aws-sdk-go/service/apprunner/apprunneriface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apprunner"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type AppRunnerServiceAPI interface {
+	DeleteService(ctx context.Context, params *apprunner.DeleteServiceInput, optFns ...func(*apprunner.Options)) (*apprunner.DeleteServiceOutput, error)
+	ListServices(ctx context.Context, params *apprunner.ListServicesInput, optFns ...func(*apprunner.Options)) (*apprunner.ListServicesOutput, error)
+}
+
 type AppRunnerService struct {
 	BaseAwsResource
-	Client     apprunneriface.AppRunnerAPI
+	Client     AppRunnerServiceAPI
 	Region     string
 	AppRunners []string
 }
@@ -22,10 +25,12 @@ func (a *AppRunnerService) GetAndSetResourceConfig(configObj config.Config) conf
 	return configObj.AppRunnerService
 }
 
-func (a *AppRunnerService) Init(session *session.Session) {
-	a.Client = apprunner.New(session)
+func (a *AppRunnerService) InitV2(cfg aws.Config) {
+	a.Client = apprunner.NewFromConfig(cfg)
 }
 
+func (a *AppRunnerService) IsUsingV2() bool { return true }
+
 func (a *AppRunnerService) ResourceName() string { return "app-runner-service" }
 
 func (a *AppRunnerService) ResourceIdentifiers() []string { return a.AppRunners }
@@ -46,6 +51,6 @@ func (a *AppRunnerService) GetAndSetIdentifiers(c context.Context, configObj con
 		return nil, err
 	}
 
-	a.AppRunners = aws.StringValueSlice(identifiers)
+	a.AppRunners = aws.ToStringSlice(identifiers)
 	return a.AppRunners, nil
 }
diff --git a/aws/resources/asg.go b/aws/resources/asg.go
index e69c3c5..257deb8 100644
--- a/aws/resources/asg.go
+++ b/aws/resources/asg.go
@@ -2,9 +2,10 @@ package resources
 
 import (
 	"context"
+	"time"
 
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -14,7 +15,7 @@ import (
 
 // Returns a formatted string of ASG Names
 func (ag *ASGroups) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	result, err := ag.Client.DescribeAutoScalingGroupsWithContext(ag.Context, &autoscaling.DescribeAutoScalingGroupsInput{})
+	result, err := ag.Client.DescribeAutoScalingGroups(ag.Context, &autoscaling.DescribeAutoScalingGroupsInput{})
 	if err != nil {
 		return nil, errors.WithStackTrace(err)
 	}
@@ -41,15 +42,15 @@ func (ag *ASGroups) nukeAll(groupNames []*string) error {
 	}
 
 	logging.Debugf("Deleting all Auto Scaling Groups in region %s", ag.Region)
-	var deletedGroupNames []*string
+	var deletedGroupNames []string
 
 	for _, groupName := range groupNames {
 		params := &autoscaling.DeleteAutoScalingGroupInput{
 			AutoScalingGroupName: groupName,
-			ForceDelete:          awsgo.Bool(true),
+			ForceDelete:          aws.Bool(true),
 		}
 
-		_, err := ag.Client.DeleteAutoScalingGroupWithContext(ag.Context, params)
+		_, err := ag.Client.DeleteAutoScalingGroup(ag.Context, params)
 
 		// Record status of this resource
 		e := report.Entry{
@@ -62,15 +63,17 @@ func (ag *ASGroups) nukeAll(groupNames []*string) error {
 		if err != nil {
 			logging.Debugf("[Failed] %s", err)
 		} else {
-			deletedGroupNames = append(deletedGroupNames, groupName)
+			deletedGroupNames = append(deletedGroupNames, *groupName)
 			logging.Debugf("Deleted Auto Scaling Group: %s", *groupName)
 		}
 	}
 
 	if len(deletedGroupNames) > 0 {
-		err := ag.Client.WaitUntilGroupNotExistsWithContext(ag.Context, &autoscaling.DescribeAutoScalingGroupsInput{
+		waiter := autoscaling.NewGroupNotExistsWaiter(ag.Client)
+		err := waiter.Wait(ag.Context, &autoscaling.DescribeAutoScalingGroupsInput{
 			AutoScalingGroupNames: deletedGroupNames,
-		})
+		}, 5*time.Minute)
+
 		if err != nil {
 			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
diff --git a/aws/resources/asg_types.go b/aws/resources/asg_types.go
index ed1c82a..33038f0 100644
--- a/aws/resources/asg_types.go
+++ b/aws/resources/asg_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/autoscaling"
-	"github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// ASGroups - represents all auto scaling groups
+type ASGroupsAPI interface {
+	DescribeAutoScalingGroups(ctx context.Context, params *autoscaling.DescribeAutoScalingGroupsInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DescribeAutoScalingGroupsOutput, error)
+	DeleteAutoScalingGroup(ctx context.Context, params *autoscaling.DeleteAutoScalingGroupInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DeleteAutoScalingGroupOutput, error)
+}
+
+// ASGroups - represents all auto-scaling groups
 type ASGroups struct {
 	BaseAwsResource
-	Client     autoscalingiface.AutoScalingAPI
+	Client     ASGroupsAPI
 	Region     string
 	GroupNames []string
 }
 
-func (ag *ASGroups) Init(session *session.Session) {
-	ag.Client = autoscaling.New(session)
+func (ag *ASGroups) InitV2(cfg aws.Config) {
+	ag.Client = autoscaling.NewFromConfig(cfg)
 }
 
+func (ag *ASGroups) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (ag *ASGroups) ResourceName() string {
 	return "asg"
@@ -33,7 +38,7 @@ func (ag *ASGroups) MaxBatchSize() int {
 	return 49
 }
 
-// ResourceIdentifiers - The group names of the auto scaling groups
+// ResourceIdentifiers - The group names of the auto-scaling groups
 func (ag *ASGroups) ResourceIdentifiers() []string {
 	return ag.GroupNames
 }
@@ -47,13 +52,13 @@ func (ag *ASGroups) GetAndSetIdentifiers(c context.Context, configObj config.Con
 		return nil, err
 	}
 
-	ag.GroupNames = awsgo.StringValueSlice(identifiers)
+	ag.GroupNames = aws.ToStringSlice(identifiers)
 	return ag.GroupNames, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (ag *ASGroups) Nuke(identifiers []string) error {
-	if err := ag.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := ag.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/backup_vault.go b/aws/resources/backup_vault.go
index dbc2d99..df28ca0 100644
--- a/aws/resources/backup_vault.go
+++ b/aws/resources/backup_vault.go
@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/backup"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/backup"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -15,9 +14,15 @@ import (
 )
 
 func (bv *BackupVault) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	names := []*string{}
-	paginator := func(output *backup.ListBackupVaultsOutput, lastPage bool) bool {
-		for _, backupVault := range output.BackupVaultList {
+	var names []*string
+	paginator := backup.NewListBackupVaultsPaginator(bv.Client, &backup.ListBackupVaultsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, backupVault := range page.BackupVaultList {
 			if configObj.BackupVault.ShouldInclude(config.ResourceValue{
 				Name: backupVault.BackupVaultName,
 				Time: backupVault.CreationDate,
@@ -26,12 +31,6 @@ func (bv *BackupVault) getAll(c context.Context, configObj config.Config) ([]*st
 			}
 		}
 
-		return !lastPage
-	}
-
-	err := bv.Client.ListBackupVaultsPagesWithContext(bv.Context, &backup.ListBackupVaultsInput{}, paginator)
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
 	}
 
 	return names, nil
@@ -50,37 +49,37 @@ func (bv *BackupVault) nuke(name *string) error {
 }
 
 func (bv *BackupVault) nukeBackupVault(name *string) error {
-	_, err := bv.Client.DeleteBackupVaultWithContext(bv.Context, &backup.DeleteBackupVaultInput{
+	_, err := bv.Client.DeleteBackupVault(bv.Context, &backup.DeleteBackupVaultInput{
 		BackupVaultName: name,
 	})
 	if err != nil {
-		logging.Debugf("[Failed] nuking the backup vault %s: %v", awsgo.StringValue(name), err)
+		logging.Debugf("[Failed] nuking the backup vault %s: %v", aws.ToString(name), err)
 		return errors.WithStackTrace(err)
 	}
 	return nil
 }
 
 func (bv *BackupVault) nukeRecoveryPoints(name *string) error {
-	logging.Debugf("Nuking the recovery points of backup vault %s", awsgo.StringValue(name))
+	logging.Debugf("Nuking the recovery points of backup vault %s", aws.ToString(name))
 
-	output, err := bv.Client.ListRecoveryPointsByBackupVaultWithContext(bv.Context, &backup.ListRecoveryPointsByBackupVaultInput{
+	output, err := bv.Client.ListRecoveryPointsByBackupVault(bv.Context, &backup.ListRecoveryPointsByBackupVaultInput{
 		BackupVaultName: name,
 	})
 
 	if err != nil {
-		logging.Debugf("[Failed] listing the recovery points of backup vault %s: %v", awsgo.StringValue(name), err)
+		logging.Debugf("[Failed] listing the recovery points of backup vault %s: %v", aws.ToString(name), err)
 		return errors.WithStackTrace(err)
 	}
 
 	for _, recoveryPoint := range output.RecoveryPoints {
-		logging.Debugf("Deleting recovery point %s from backup vault %s", awsgo.StringValue(recoveryPoint.RecoveryPointArn), awsgo.StringValue(name))
-		_, err := bv.Client.DeleteRecoveryPointWithContext(bv.Context, &backup.DeleteRecoveryPointInput{
+		logging.Debugf("Deleting recovery point %s from backup vault %s", aws.ToString(recoveryPoint.RecoveryPointArn), aws.ToString(name))
+		_, err := bv.Client.DeleteRecoveryPoint(bv.Context, &backup.DeleteRecoveryPointInput{
 			BackupVaultName:  name,
 			RecoveryPointArn: recoveryPoint.RecoveryPointArn,
 		})
 
 		if err != nil {
-			logging.Debugf("[Failed] nuking the backup vault %s: %v", awsgo.StringValue(name), err)
+			logging.Debugf("[Failed] nuking the backup vault %s: %v", aws.ToString(name), err)
 			return errors.WithStackTrace(err)
 		}
 	}
@@ -88,11 +87,11 @@ func (bv *BackupVault) nukeRecoveryPoints(name *string) error {
 	// wait until all the recovery points nuked successfully
 	err = bv.WaitUntilRecoveryPointsDeleted(name)
 	if err != nil {
-		logging.Debugf("[Failed] waiting deletion of recovery points for backup vault %s: %v", awsgo.StringValue(name), err)
+		logging.Debugf("[Failed] waiting deletion of recovery points for backup vault %s: %v", aws.ToString(name), err)
 		return errors.WithStackTrace(err)
 	}
 
-	logging.Debugf("[Ok] successfully nuked recovery points of backup vault %s", awsgo.StringValue(name))
+	logging.Debugf("[Ok] successfully nuked recovery points of backup vault %s", aws.ToString(name))
 
 	return nil
 }
@@ -109,7 +108,7 @@ func (bv *BackupVault) WaitUntilRecoveryPointsDeleted(name *string) error {
 		case <-timeoutCtx.Done():
 			return fmt.Errorf("recovery point deletion check timed out after 1 minute")
 		case <-ticker.C:
-			output, err := bv.Client.ListRecoveryPointsByBackupVaultWithContext(bv.Context, &backup.ListRecoveryPointsByBackupVaultInput{
+			output, err := bv.Client.ListRecoveryPointsByBackupVault(bv.Context, &backup.ListRecoveryPointsByBackupVaultInput{
 				BackupVaultName: name,
 			})
 			if err != nil {
@@ -138,7 +137,7 @@ func (bv *BackupVault) nukeAll(names []*string) error {
 		err := bv.nuke(name)
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   aws.StringValue(name),
+			Identifier:   aws.ToString(name),
 			ResourceType: "Backup Vault",
 			Error:        err,
 		}
@@ -148,7 +147,7 @@ func (bv *BackupVault) nukeAll(names []*string) error {
 			logging.Debugf("[Failed] %s", err)
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Debugf("Deleted backup vault: %s", aws.StringValue(name))
+			logging.Debugf("Deleted backup vault: %s", aws.ToString(name))
 		}
 	}
 
diff --git a/aws/resources/backup_vault_types.go b/aws/resources/backup_vault_types.go
index 4c39f15..d4b90db 100644
--- a/aws/resources/backup_vault_types.go
+++ b/aws/resources/backup_vault_types.go
@@ -3,25 +3,32 @@ 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/backup"
-	"github.com/aws/aws-sdk-go/service/backup/backupiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/backup"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type BackupVaultAPI interface {
+	DeleteBackupVault(ctx context.Context, params *backup.DeleteBackupVaultInput, optFns ...func(*backup.Options)) (*backup.DeleteBackupVaultOutput, error)
+	DeleteRecoveryPoint(ctx context.Context, params *backup.DeleteRecoveryPointInput, optFns ...func(*backup.Options)) (*backup.DeleteRecoveryPointOutput, error)
+	ListBackupVaults(ctx context.Context, params *backup.ListBackupVaultsInput, optFns ...func(*backup.Options)) (*backup.ListBackupVaultsOutput, error)
+	ListRecoveryPointsByBackupVault(ctx context.Context, params *backup.ListRecoveryPointsByBackupVaultInput, optFns ...func(*backup.Options)) (*backup.ListRecoveryPointsByBackupVaultOutput, error)
+}
+
 type BackupVault struct {
 	BaseAwsResource
-	Client backupiface.BackupAPI
+	Client BackupVaultAPI
 	Region string
 	Names  []string
 }
 
-func (bv *BackupVault) Init(session *session.Session) {
-	bv.Client = backup.New(session)
+func (bv *BackupVault) InitV2(cfg aws.Config) {
+	bv.Client = backup.NewFromConfig(cfg)
 }
 
+func (bv *BackupVault) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (bv *BackupVault) ResourceName() string {
 	return "backup-vault"
@@ -45,13 +52,13 @@ func (bv *BackupVault) GetAndSetIdentifiers(c context.Context, configObj config.
 		return nil, err
 	}
 
-	bv.Names = awsgo.StringValueSlice(identifiers)
+	bv.Names = aws.ToStringSlice(identifiers)
 	return bv.Names, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (bv *BackupVault) Nuke(identifiers []string) error {
-	if err := bv.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := bv.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/cloudtrail.go b/aws/resources/cloudtrail.go
index 7cad40a..1c371f9 100644
--- a/aws/resources/cloudtrail.go
+++ b/aws/resources/cloudtrail.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudtrail"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudtrail"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -12,24 +12,21 @@ import (
 )
 
 func (ct *CloudtrailTrail) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	param := &cloudtrail.ListTrailsInput{}
+	var trailIds []*string
+	paginator := cloudtrail.NewListTrailsPaginator(ct.Client, &cloudtrail.ListTrailsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
 
-	trailIds := []*string{}
-	paginator := func(output *cloudtrail.ListTrailsOutput, lastPage bool) bool {
-		for _, trailInfo := range output.Trails {
+		for _, trailInfo := range page.Trails {
 			if configObj.CloudtrailTrail.ShouldInclude(config.ResourceValue{
 				Name: trailInfo.Name,
 			}) {
 				trailIds = append(trailIds, trailInfo.TrailARN)
 			}
 		}
-
-		return !lastPage
-	}
-
-	err := ct.Client.ListTrailsPagesWithContext(ct.Context, param, paginator)
-	if err != nil {
-		return trailIds, errors.WithStackTrace(err)
 	}
 
 	return trailIds, nil
@@ -49,10 +46,10 @@ func (ct *CloudtrailTrail) nukeAll(arns []*string) error {
 			Name: arn,
 		}
 
-		_, err := ct.Client.DeleteTrailWithContext(ct.Context, params)
+		_, err := ct.Client.DeleteTrail(ct.Context, params)
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   aws.StringValue(arn),
+			Identifier:   aws.ToString(arn),
 			ResourceType: "Cloudtrail Trail",
 			Error:        err,
 		}
@@ -62,7 +59,7 @@ func (ct *CloudtrailTrail) nukeAll(arns []*string) error {
 			logging.Debugf("[Failed] %s", err)
 		} else {
 			deletedArns = append(deletedArns, arn)
-			logging.Debugf("Deleted Cloudtrail Trail: %s", aws.StringValue(arn))
+			logging.Debugf("Deleted Cloudtrail Trail: %s", aws.ToString(arn))
 		}
 	}
 
diff --git a/aws/resources/cloudtrail_types.go b/aws/resources/cloudtrail_types.go
index 2d5a1bd..29e475d 100644
--- a/aws/resources/cloudtrail_types.go
+++ b/aws/resources/cloudtrail_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/cloudtrail"
-	"github.com/aws/aws-sdk-go/service/cloudtrail/cloudtrailiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudtrail"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// CloudWatchLogGroup - represents all ec2 instances
+type CloudtrailTrailAPI interface {
+	ListTrails(ctx context.Context, params *cloudtrail.ListTrailsInput, optFns ...func(*cloudtrail.Options)) (*cloudtrail.ListTrailsOutput, error)
+	DeleteTrail(ctx context.Context, params *cloudtrail.DeleteTrailInput, optFns ...func(*cloudtrail.Options)) (*cloudtrail.DeleteTrailOutput, error)
+}
+
+// CloudtrailTrail - represents all CloudTrails
 type CloudtrailTrail struct {
 	BaseAwsResource
-	Client cloudtrailiface.CloudTrailAPI
+	Client CloudtrailTrailAPI
 	Region string
 	Arns   []string
 }
 
-func (ct *CloudtrailTrail) Init(session *session.Session) {
-	ct.Client = cloudtrail.New(session)
+func (ct *CloudtrailTrail) InitV2(cfg aws.Config) {
+	ct.Client = cloudtrail.NewFromConfig(cfg)
 }
 
+func (ct *CloudtrailTrail) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (ct *CloudtrailTrail) ResourceName() string {
 	return "cloudtrail"
@@ -47,13 +52,13 @@ func (ct *CloudtrailTrail) GetAndSetIdentifiers(c context.Context, configObj con
 		return nil, err
 	}
 
-	ct.Arns = awsgo.StringValueSlice(identifiers)
+	ct.Arns = aws.ToStringSlice(identifiers)
 	return ct.Arns, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (ct *CloudtrailTrail) Nuke(identifiers []string) error {
-	if err := ct.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := ct.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/cloudwatch_alarm.go b/aws/resources/cloudwatch_alarm.go
index 3cc543a..8972602 100644
--- a/aws/resources/cloudwatch_alarm.go
+++ b/aws/resources/cloudwatch_alarm.go
@@ -3,8 +3,9 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -13,35 +14,38 @@ import (
 )
 
 func (cw *CloudWatchAlarms) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	allAlarms := []*string{}
+	var allAlarms []*string
 	input := &cloudwatch.DescribeAlarmsInput{
-		AlarmTypes: aws.StringSlice([]string{cloudwatch.AlarmTypeMetricAlarm, cloudwatch.AlarmTypeCompositeAlarm}),
+		AlarmTypes: []types.AlarmType{types.AlarmTypeMetricAlarm, types.AlarmTypeCompositeAlarm},
 	}
-	err := cw.Client.DescribeAlarmsPagesWithContext(
-		cw.Context,
-		input,
-		func(page *cloudwatch.DescribeAlarmsOutput, lastPage bool) bool {
-			for _, alarm := range page.MetricAlarms {
-				if configObj.CloudWatchAlarm.ShouldInclude(config.ResourceValue{
-					Name: alarm.AlarmName,
-					Time: alarm.AlarmConfigurationUpdatedTimestamp,
-				}) {
-					allAlarms = append(allAlarms, alarm.AlarmName)
-				}
+
+	paginator := cloudwatch.NewDescribeAlarmsPaginator(cw.Client, input)
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, alarm := range page.MetricAlarms {
+			if configObj.CloudWatchAlarm.ShouldInclude(config.ResourceValue{
+				Name: alarm.AlarmName,
+				Time: alarm.AlarmConfigurationUpdatedTimestamp,
+			}) {
+				allAlarms = append(allAlarms, alarm.AlarmName)
 			}
+		}
 
-			for _, alarm := range page.CompositeAlarms {
-				if configObj.CloudWatchAlarm.ShouldInclude(config.ResourceValue{
-					Name: alarm.AlarmName,
-					Time: alarm.AlarmConfigurationUpdatedTimestamp,
-				}) {
-					allAlarms = append(allAlarms, alarm.AlarmName)
-				}
+		for _, alarm := range page.CompositeAlarms {
+			if configObj.CloudWatchAlarm.ShouldInclude(config.ResourceValue{
+				Name: alarm.AlarmName,
+				Time: alarm.AlarmConfigurationUpdatedTimestamp,
+			}) {
+				allAlarms = append(allAlarms, alarm.AlarmName)
 			}
-			return !lastPage
-		},
-	)
-	return allAlarms, errors.WithStackTrace(err)
+		}
+	}
+
+	return allAlarms, nil
 }
 
 func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
@@ -62,9 +66,9 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	logging.Debugf("Deleting CloudWatch Alarms in region %s", cw.Region)
 
 	// If the alarm's type is composite alarm, remove the dependency by removing the rule.
-	alarms, err := cw.Client.DescribeAlarmsWithContext(cw.Context, &cloudwatch.DescribeAlarmsInput{
-		AlarmTypes: aws.StringSlice([]string{cloudwatch.AlarmTypeMetricAlarm, cloudwatch.AlarmTypeCompositeAlarm}),
-		AlarmNames: identifiers,
+	alarms, err := cw.Client.DescribeAlarms(cw.Context, &cloudwatch.DescribeAlarmsInput{
+		AlarmTypes: []types.AlarmType{types.AlarmTypeMetricAlarm, types.AlarmTypeCompositeAlarm},
+		AlarmNames: aws.ToStringSlice(identifiers),
 	})
 	if err != nil {
 		logging.Debugf("[Failed] %s", err)
@@ -74,7 +78,7 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	for _, compositeAlarm := range alarms.CompositeAlarms {
 		compositeAlarmNames = append(compositeAlarmNames, compositeAlarm.AlarmName)
 
-		_, err := cw.Client.PutCompositeAlarmWithContext(cw.Context, &cloudwatch.PutCompositeAlarmInput{
+		_, err := cw.Client.PutCompositeAlarm(cw.Context, &cloudwatch.PutCompositeAlarmInput{
 			AlarmName: compositeAlarm.AlarmName,
 			AlarmRule: aws.String("FALSE"),
 		})
@@ -84,25 +88,25 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 
 		// Note: for composite alarms, we need to delete one by one according to the documentation
 		// - https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DeleteAlarms.html.
-		_, err = cw.Client.DeleteAlarmsWithContext(cw.Context, &cloudwatch.DeleteAlarmsInput{
-			AlarmNames: []*string{compositeAlarm.AlarmName},
+		_, err = cw.Client.DeleteAlarms(cw.Context, &cloudwatch.DeleteAlarmsInput{
+			AlarmNames: []string{*compositeAlarm.AlarmName},
 		})
 
 		// Record status of this resource
 		report.Record(report.Entry{
-			Identifier:   aws.StringValue(compositeAlarm.AlarmName),
+			Identifier:   aws.ToString(compositeAlarm.AlarmName),
 			ResourceType: "CloudWatch Alarm",
 			Error:        err,
 		})
 	}
 
 	nonCompositeAlarms := util.Difference(identifiers, compositeAlarmNames)
-	input := cloudwatch.DeleteAlarmsInput{AlarmNames: nonCompositeAlarms}
-	_, err = cw.Client.DeleteAlarmsWithContext(cw.Context, &input)
+	input := cloudwatch.DeleteAlarmsInput{AlarmNames: aws.ToStringSlice(nonCompositeAlarms)}
+	_, err = cw.Client.DeleteAlarms(cw.Context, &input)
 
 	// Record status of this resource
 	e := report.BatchEntry{
-		Identifiers:  aws.StringValueSlice(nonCompositeAlarms),
+		Identifiers:  aws.ToStringSlice(nonCompositeAlarms),
 		ResourceType: "CloudWatch Alarm",
 		Error:        err,
 	}
@@ -114,7 +118,7 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	}
 
 	for _, alarmName := range identifiers {
-		logging.Debugf("[OK] CloudWatch Alarm %s was deleted in %s", aws.StringValue(alarmName), cw.Region)
+		logging.Debugf("[OK] CloudWatch Alarm %s was deleted in %s", aws.ToString(alarmName), cw.Region)
 	}
 	return nil
 }
diff --git a/aws/resources/cloudwatch_alarm_types.go b/aws/resources/cloudwatch_alarm_types.go
index 767d82f..f9b6f32 100644
--- a/aws/resources/cloudwatch_alarm_types.go
+++ b/aws/resources/cloudwatch_alarm_types.go
@@ -3,26 +3,32 @@ 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/cloudwatch"
-	"github.com/aws/aws-sdk-go/service/cloudwatch/cloudwatchiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type CloudWatchAlarmsAPI interface {
+	DescribeAlarms(ctx context.Context, params *cloudwatch.DescribeAlarmsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.DescribeAlarmsOutput, error)
+	DeleteAlarms(ctx context.Context, params *cloudwatch.DeleteAlarmsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.DeleteAlarmsOutput, error)
+	PutCompositeAlarm(ctx context.Context, params *cloudwatch.PutCompositeAlarmInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.PutCompositeAlarmOutput, error)
+}
+
 // CloudWatchAlarms - represents all CloudWatchAlarms that should be deleted.
 type CloudWatchAlarms struct {
 	BaseAwsResource
-	Client     cloudwatchiface.CloudWatchAPI
+	Client     CloudWatchAlarmsAPI
 	Region     string
 	AlarmNames []string
 }
 
-func (cw *CloudWatchAlarms) Init(session *session.Session) {
-	cw.Client = cloudwatch.New(session)
+func (cw *CloudWatchAlarms) InitV2(cfg aws.Config) {
+	cw.Client = cloudwatch.NewFromConfig(cfg)
 }
 
+func (cw *CloudWatchAlarms) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (cw *CloudWatchAlarms) ResourceName() string {
 	return "cloudwatch-alarm"
@@ -47,13 +53,13 @@ func (cw *CloudWatchAlarms) GetAndSetIdentifiers(c context.Context, configObj co
 		return nil, err
 	}
 
-	cw.AlarmNames = awsgo.StringValueSlice(identifiers)
+	cw.AlarmNames = aws.ToStringSlice(identifiers)
 	return cw.AlarmNames, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (cw *CloudWatchAlarms) Nuke(identifiers []string) error {
-	if err := cw.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := cw.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/cloudwatch_dashboard.go b/aws/resources/cloudwatch_dashboard.go
index 377af00..f77377c 100644
--- a/aws/resources/cloudwatch_dashboard.go
+++ b/aws/resources/cloudwatch_dashboard.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -12,25 +12,26 @@ import (
 )
 
 func (cwdb *CloudWatchDashboards) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	allDashboards := []*string{}
-	input := &cloudwatch.ListDashboardsInput{}
-	err := cwdb.Client.ListDashboardsPagesWithContext(
-		cwdb.Context,
-		input,
-		func(page *cloudwatch.ListDashboardsOutput, lastPage bool) bool {
-			for _, dashboard := range page.DashboardEntries {
-				if configObj.CloudWatchDashboard.ShouldInclude(config.ResourceValue{
-					Name: dashboard.DashboardName,
-					Time: dashboard.LastModified,
-				}) {
-					allDashboards = append(allDashboards, dashboard.DashboardName)
-				}
+	var allDashboards []*string
+
+	paginator := cloudwatch.NewListDashboardsPaginator(cwdb.Client, &cloudwatch.ListDashboardsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, dashboard := range page.DashboardEntries {
+			if configObj.CloudWatchDashboard.ShouldInclude(config.ResourceValue{
+				Name: dashboard.DashboardName,
+				Time: dashboard.LastModified,
+			}) {
+				allDashboards = append(allDashboards, dashboard.DashboardName)
 			}
+		}
+	}
 
-			return !lastPage
-		},
-	)
-	return allDashboards, errors.WithStackTrace(err)
+	return allDashboards, nil
 }
 
 func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
@@ -49,12 +50,12 @@ func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
 	}
 
 	logging.Debugf("Deleting CloudWatch Dashboards in region %s", cwdb.Region)
-	input := cloudwatch.DeleteDashboardsInput{DashboardNames: identifiers}
-	_, err := cwdb.Client.DeleteDashboardsWithContext(cwdb.Context, &input)
+	input := cloudwatch.DeleteDashboardsInput{DashboardNames: aws.ToStringSlice(identifiers)}
+	_, err := cwdb.Client.DeleteDashboards(cwdb.Context, &input)
 
 	// Record status of this resource
 	e := report.BatchEntry{
-		Identifiers:  aws.StringValueSlice(identifiers),
+		Identifiers:  aws.ToStringSlice(identifiers),
 		ResourceType: "CloudWatch Dashboard",
 		Error:        err,
 	}
@@ -66,7 +67,7 @@ func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
 	}
 
 	for _, dashboardName := range identifiers {
-		logging.Debugf("[OK] CloudWatch Dashboard %s was deleted in %s", aws.StringValue(dashboardName), cwdb.Region)
+		logging.Debugf("[OK] CloudWatch Dashboard %s was deleted in %s", aws.ToString(dashboardName), cwdb.Region)
 	}
 	return nil
 }
diff --git a/aws/resources/cloudwatch_dashboard_types.go b/aws/resources/cloudwatch_dashboard_types.go
index 95e8828..a73a2b3 100644
--- a/aws/resources/cloudwatch_dashboard_types.go
+++ b/aws/resources/cloudwatch_dashboard_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/cloudwatch"
-	"github.com/aws/aws-sdk-go/service/cloudwatch/cloudwatchiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type CloudWatchDashboardsAPI interface {
+	ListDashboards(ctx context.Context, params *cloudwatch.ListDashboardsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.ListDashboardsOutput, error)
+	DeleteDashboards(ctx context.Context, params *cloudwatch.DeleteDashboardsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.DeleteDashboardsOutput, error)
+}
+
 // CloudWatchDashboards - represents all CloudWatch Dashboards that should be deleted.
 type CloudWatchDashboards struct {
 	BaseAwsResource
-	Client         cloudwatchiface.CloudWatchAPI
+	Client         CloudWatchDashboardsAPI
 	Region         string
 	DashboardNames []string
 }
 
-func (cwdb *CloudWatchDashboards) Init(session *session.Session) {
-	cwdb.Client = cloudwatch.New(session)
+func (cwdb *CloudWatchDashboards) InitV2(cfg aws.Config) {
+	cwdb.Client = cloudwatch.NewFromConfig(cfg)
 }
 
+func (cwdb *CloudWatchDashboards) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (cwdb *CloudWatchDashboards) ResourceName() string {
 	return "cloudwatch-dashboard"
@@ -46,13 +51,13 @@ func (cwdb *CloudWatchDashboards) GetAndSetIdentifiers(c context.Context, config
 		return nil, err
 	}
 
-	cwdb.DashboardNames = awsgo.StringValueSlice(identifiers)
+	cwdb.DashboardNames = aws.ToStringSlice(identifiers)
 	return cwdb.DashboardNames, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (cwdb *CloudWatchDashboards) Nuke(identifiers []string) error {
-	if err := cwdb.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := cwdb.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/cloudwatch_loggroup.go b/aws/resources/cloudwatch_loggroup.go
index 031e122..e7e4ce9 100644
--- a/aws/resources/cloudwatch_loggroup.go
+++ b/aws/resources/cloudwatch_loggroup.go
@@ -2,45 +2,46 @@ package resources
 
 import (
 	"context"
+	"errors"
 	"sync"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/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"
+	goerr "github.com/gruntwork-io/go-commons/errors"
 	"github.com/hashicorp/go-multierror"
 )
 
 func (csr *CloudWatchLogGroups) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	allLogGroups := []*string{}
-	err := csr.Client.DescribeLogGroupsPagesWithContext(
-		csr.Context,
-		&cloudwatchlogs.DescribeLogGroupsInput{},
-		func(page *cloudwatchlogs.DescribeLogGroupsOutput, lastPage bool) bool {
-			for _, logGroup := range page.LogGroups {
-				var creationTime *time.Time
-				if logGroup.CreationTime != nil {
-					// Convert milliseconds since epoch to time.Time object
-					creationTime = aws.Time(time.Unix(0, aws.Int64Value(logGroup.CreationTime)*int64(time.Millisecond)))
-				}
-
-				if configObj.CloudWatchLogGroup.ShouldInclude(config.ResourceValue{
-					Name: logGroup.LogGroupName,
-					Time: creationTime,
-				}) {
-					allLogGroups = append(allLogGroups, logGroup.LogGroupName)
-				}
+	var allLogGroups []*string
+
+	paginator := cloudwatchlogs.NewDescribeLogGroupsPaginator(csr.Client, &cloudwatchlogs.DescribeLogGroupsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, goerr.WithStackTrace(err)
+		}
+
+		for _, logGroup := range page.LogGroups {
+			var creationTime *time.Time
+			if logGroup.CreationTime != nil {
+				// Convert milliseconds since epoch to time.Time object
+				creationTime = aws.Time(time.Unix(0, aws.ToInt64(logGroup.CreationTime)*int64(time.Millisecond)))
 			}
-			return !lastPage
-		},
-	)
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
+
+			if configObj.CloudWatchLogGroup.ShouldInclude(config.ResourceValue{
+				Name: logGroup.LogGroupName,
+				Time: creationTime,
+			}) {
+				allLogGroups = append(allLogGroups, logGroup.LogGroupName)
+			}
+		}
 	}
+
 	return allLogGroups, nil
 }
 
@@ -77,14 +78,15 @@ func (csr *CloudWatchLogGroups) 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" {
+			var awsErr *types.OperationAbortedException
+			if !errors.As(err, &awsErr) {
 				allErrs = multierror.Append(allErrs, err)
 			}
 		}
 	}
 	finalErr := allErrs.ErrorOrNil()
 	if finalErr != nil {
-		return errors.WithStackTrace(finalErr)
+		return goerr.WithStackTrace(finalErr)
 	}
 	return nil
 }
@@ -94,11 +96,11 @@ func (csr *CloudWatchLogGroups) nukeAll(identifiers []*string) error {
 func (csr *CloudWatchLogGroups) deleteAsync(wg *sync.WaitGroup, errChan chan error, logGroupName *string) {
 	defer wg.Done()
 	input := &cloudwatchlogs.DeleteLogGroupInput{LogGroupName: logGroupName}
-	_, err := csr.Client.DeleteLogGroupWithContext(csr.Context, input)
+	_, err := csr.Client.DeleteLogGroup(csr.Context, input)
 
 	// Record status of this resource
 	e := report.Entry{
-		Identifier:   aws.StringValue(logGroupName),
+		Identifier:   aws.ToString(logGroupName),
 		ResourceType: "CloudWatch Log Group",
 		Error:        err,
 	}
@@ -106,7 +108,7 @@ func (csr *CloudWatchLogGroups) deleteAsync(wg *sync.WaitGroup, errChan chan err
 
 	errChan <- err
 
-	logGroupNameStr := aws.StringValue(logGroupName)
+	logGroupNameStr := aws.ToString(logGroupName)
 	if err == nil {
 		logging.Debugf("[OK] CloudWatch Log Group %s deleted in %s", logGroupNameStr, csr.Region)
 	} else {
diff --git a/aws/resources/cloudwatch_loggroup_types.go b/aws/resources/cloudwatch_loggroup_types.go
index c5ee040..4b072b3 100644
--- a/aws/resources/cloudwatch_loggroup_types.go
+++ b/aws/resources/cloudwatch_loggroup_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/cloudwatchlogs"
-	"github.com/aws/aws-sdk-go/service/cloudwatchlogs/cloudwatchlogsiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// CloudWatchLogGroup - represents all ec2 instances
+type CloudWatchLogGroupsAPI interface {
+	DescribeLogGroups(ctx context.Context, params *cloudwatchlogs.DescribeLogGroupsInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DescribeLogGroupsOutput, error)
+	DeleteLogGroup(ctx context.Context, params *cloudwatchlogs.DeleteLogGroupInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteLogGroupOutput, error)
+}
+
+// CloudWatchLogGroups - represents all Cloud Watch Log Groups
 type CloudWatchLogGroups struct {
 	BaseAwsResource
-	Client cloudwatchlogsiface.CloudWatchLogsAPI
+	Client CloudWatchLogGroupsAPI
 	Region string
 	Names  []string
 }
 
-func (csr *CloudWatchLogGroups) Init(session *session.Session) {
-	csr.Client = cloudwatchlogs.New(session)
+func (csr *CloudWatchLogGroups) InitV2(cfg aws.Config) {
+	csr.Client = cloudwatchlogs.NewFromConfig(cfg)
 }
 
+func (csr *CloudWatchLogGroups) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (csr *CloudWatchLogGroups) ResourceName() string {
 	return "cloudwatch-loggroup"
@@ -50,13 +55,13 @@ func (csr *CloudWatchLogGroups) GetAndSetIdentifiers(c context.Context, configOb
 		return nil, err
 	}
 
-	csr.Names = awsgo.StringValueSlice(identifiers)
+	csr.Names = aws.ToStringSlice(identifiers)
 	return csr.Names, nil
 }
 
 // Nuke - nuke 'em all!!!
 func (csr *CloudWatchLogGroups) Nuke(identifiers []string) error {
-	if err := csr.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := csr.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 
diff --git a/aws/resources/codedeploy_application.go b/aws/resources/codedeploy_application.go
index d3fca4f..5a086d6 100644
--- a/aws/resources/codedeploy_application.go
+++ b/aws/resources/codedeploy_application.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/codedeploy"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/codedeploy"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -14,24 +14,23 @@ import (
 )
 
 func (cda *CodeDeployApplications) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	codeDeployApplicationsFilteredByName := []string{}
-
-	err := cda.Client.ListApplicationsPagesWithContext(
-		cda.Context,
-		&codedeploy.ListApplicationsInput{}, func(page *codedeploy.ListApplicationsOutput, lastPage bool) bool {
-			for _, application := range page.Applications {
-				// Check if the CodeDeploy Application should be excluded by name as that information is available to us here.
-				// CreationDate is not available in the ListApplications API call, so we can't filter by that here, but we do filter by it later.
-				// By filtering the name here, we can reduce the number of BatchGetApplication API calls we have to make.
-				if configObj.CodeDeployApplications.ShouldInclude(config.ResourceValue{Name: application}) {
-					codeDeployApplicationsFilteredByName = append(codeDeployApplicationsFilteredByName, *application)
-				}
-			}
+	var codeDeployApplicationsFilteredByName []string
 
-			return !lastPage
-		})
-	if err != nil {
-		return nil, err
+	paginator := codedeploy.NewListApplicationsPaginator(cda.Client, &codedeploy.ListApplicationsInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, application := range page.Applications {
+			// Check if the CodeDeploy Application should be excluded by name as that information is available to us here.
+			// CreationDate is not available in the ListApplications API call, so we can't filter by that here, but we do filter by it later.
+			// By filtering the name here, we can reduce the number of BatchGetApplication API calls we have to make.
+			if configObj.CodeDeployApplications.ShouldInclude(config.ResourceValue{Name: aws.String(application)}) {
+				codeDeployApplicationsFilteredByName = append(codeDeployApplicationsFilteredByName, application)
+			}
+		}
 	}
 
 	// Check if the CodeDeploy Application should be excluded by CreationDate and return.
@@ -57,9 +56,9 @@ func (cda *CodeDeployApplications) batchDescribeAndFilter(identifiers []string,
 		}
 
 		// get the next batch of identifiers
-		batch := aws.StringSlice(identifiers[:batchSize])
+		batch := identifiers[:batchSize]
 		// then using that batch of identifiers, get the applicationsinfo
-		resp, err := cda.Client.BatchGetApplicationsWithContext(
+		resp, err := cda.Client.BatchGetApplications(
 			cda.Context,
 			&codedeploy.BatchGetApplicationsInput{ApplicationNames: batch},
 		)
@@ -120,7 +119,7 @@ func (cda *CodeDeployApplications) nukeAll(identifiers []string) error {
 func (cda *CodeDeployApplications) deleteAsync(wg *sync.WaitGroup, errChan chan<- error, identifier string) {
 	defer wg.Done()
 
-	_, err := cda.Client.DeleteApplicationWithContext(cda.Context, &codedeploy.DeleteApplicationInput{ApplicationName: &identifier})
+	_, err := cda.Client.DeleteApplication(cda.Context, &codedeploy.DeleteApplicationInput{ApplicationName: &identifier})
 	if err != nil {
 		errChan <- err
 	}
diff --git a/aws/resources/codedeploy_application_types.go b/aws/resources/codedeploy_application_types.go
index 731191e..0d115ff 100644
--- a/aws/resources/codedeploy_application_types.go
+++ b/aws/resources/codedeploy_application_types.go
@@ -3,26 +3,32 @@ 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/codedeploy"
-	"github.com/aws/aws-sdk-go/service/codedeploy/codedeployiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/codedeploy"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type CodeDeployApplicationsAPI interface {
+	ListApplications(ctx context.Context, params *codedeploy.ListApplicationsInput, optFns ...func(*codedeploy.Options)) (*codedeploy.ListApplicationsOutput, error)
+	BatchGetApplications(ctx context.Context, params *codedeploy.BatchGetApplicationsInput, optFns ...func(*codedeploy.Options)) (*codedeploy.BatchGetApplicationsOutput, error)
+	DeleteApplication(ctx context.Context, params *codedeploy.DeleteApplicationInput, optFns ...func(*codedeploy.Options)) (*codedeploy.DeleteApplicationOutput, error)
+}
+
 // CodeDeployApplications - represents all codedeploy applications
 type CodeDeployApplications struct {
 	BaseAwsResource
-	Client   codedeployiface.CodeDeployAPI
+	Client   CodeDeployApplicationsAPI
 	Region   string
 	AppNames []string
 }
 
-func (cda *CodeDeployApplications) Init(session *session.Session) {
-	cda.Client = codedeploy.New(session)
+func (cda *CodeDeployApplications) InitV2(cfg aws.Config) {
+	cda.Client = codedeploy.NewFromConfig(cfg)
 }
 
+func (cda *CodeDeployApplications) IsUsingV2() bool { return true }
+
 // ResourceName - the simple name of the aws resource
 func (cda *CodeDeployApplications) ResourceName() string {
 	return "codedeploy-application"
@@ -48,7 +54,7 @@ func (cda *CodeDeployApplications) GetAndSetIdentifiers(c context.Context, confi
 		return nil, err
 	}
 
-	cda.AppNames = awsgo.StringValueSlice(identifiers)
+	cda.AppNames = aws.ToStringSlice(identifiers)
 	return cda.AppNames, nil
 }
 
diff --git a/aws/resources/config_recorder.go b/aws/resources/config_recorder.go
index dab6139..5896240 100644
--- a/aws/resources/config_recorder.go
+++ b/aws/resources/config_recorder.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/configservice"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/configservice"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -13,10 +13,10 @@ import (
 
 func (csr *ConfigServiceRecorders) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 
-	configRecorderNames := []*string{}
+	var configRecorderNames []*string
 
 	param := &configservice.DescribeConfigurationRecordersInput{}
-	output, err := csr.Client.DescribeConfigurationRecordersWithContext(csr.Context, param)
+	output, err := csr.Client.DescribeConfigurationRecorders(csr.Context, param)
 	if err != nil {
 		return []*string{}, errors.WithStackTrace(err)
 	}
@@ -45,7 +45,7 @@ func (csr *ConfigServiceRecorders) nukeAll(configRecorderNames []string) error {
 			ConfigurationRecorderName: aws.String(configRecorderName),
 		}
 
-		_, err := csr.Client.DeleteConfigurationRecorderWithContext(csr.Context, params)
+		_, err := csr.Client.DeleteConfigurationRecorder(csr.Context, params)
 
 		// Record status of this resource
 		e := report.Entry{
diff --git a/aws/resources/config_recorder_types.go b/aws/resources/config_recorder_types.go
index 72b3cae..ee33b57 100644
--- a/aws/resources/config_recorder_types.go
+++ b/aws/resources/config_recorder_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/configservice"
-	"github.com/aws/aws-sdk-go/service/configservice/configserviceiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/configservice"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type ConfigServiceRecordersAPI interface {
+	DescribeConfigurationRecorders(ctx context.Context, params *configservice.DescribeConfigurationRecordersInput, optFns ...func(*configservice.Options)) (*configservice.DescribeConfigurationRecordersOutput, error)
+	DeleteConfigurationRecorder(ctx context.Context, params *configservice.DeleteConfigurationRecorderInput, optFns ...func(*configservice.Options)) (*configservice.DeleteConfigurationRecorderOutput, error)
+}
+
 type ConfigServiceRecorders struct {
 	BaseAwsResource
-	Client        configserviceiface.ConfigServiceAPI
+	Client        ConfigServiceRecordersAPI
 	Region        string
 	RecorderNames []string
 }
 
-func (csr *ConfigServiceRecorders) Init(session *session.Session) {
-	csr.Client = configservice.New(session)
+func (csr *ConfigServiceRecorders) InitV2(cfg aws.Config) {
+	csr.Client = configservice.NewFromConfig(cfg)
 }
 
+func (csr *ConfigServiceRecorders) IsUsingV2() bool { return true }
+
 func (csr *ConfigServiceRecorders) ResourceName() string {
 	return "config-recorders"
 }
@@ -44,7 +49,7 @@ func (csr *ConfigServiceRecorders) GetAndSetIdentifiers(c context.Context, confi
 		return nil, err
 	}
 
-	csr.RecorderNames = awsgo.StringValueSlice(identifiers)
+	csr.RecorderNames = aws.ToStringSlice(identifiers)
 	return csr.RecorderNames, nil
 }
 
diff --git a/aws/resources/config_service.go b/aws/resources/config_service.go
index 2499907..cc626e5 100644
--- a/aws/resources/config_service.go
+++ b/aws/resources/config_service.go
@@ -4,8 +4,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/configservice"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/configservice"
+	"github.com/aws/aws-sdk-go-v2/service/configservice/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -14,26 +15,21 @@ import (
 )
 
 func (csr *ConfigServiceRule) getAll(c context.Context, configObj config.Config) ([]*string, error) {
-	configRuleNames := []*string{}
+	var configRuleNames []*string
+	paginator := configservice.NewDescribeConfigRulesPaginator(csr.Client, &configservice.DescribeConfigRulesInput{})
+	for paginator.HasMorePages() {
+		output, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, errors.WithStackTrace(err)
+		}
 
-	paginator := func(output *configservice.DescribeConfigRulesOutput, lastPage bool) bool {
 		for _, configRule := range output.ConfigRules {
 			if configObj.ConfigServiceRule.ShouldInclude(config.ResourceValue{
 				Name: configRule.ConfigRuleName,
-			}) && *configRule.ConfigRuleState == "ACTIVE" {
+			}) && configRule.ConfigRuleState == types.ConfigRuleStateActive {
 				configRuleNames = append(configRuleNames, configRule.ConfigRuleName)
 			}
 		}
-
-		return !lastPage
-	}
-
-	// Pass an empty config rules input, to signify we want all config rules returned
-	param := &configservice.DescribeConfigRulesInput{}
-
-	err := csr.Client.DescribeConfigRulesPagesWithContext(csr.Context, param, paginator)
-	if err != nil {
-		return nil, errors.WithStackTrace(err)
 	}
 
 	return configRuleNames, nil
@@ -49,8 +45,8 @@ func (csr *ConfigServiceRule) nukeAll(configRuleNames []string) error {
 	for _, configRuleName := range configRuleNames {
 		logging.Debug(fmt.Sprintf("Start deleting config service rule: %s", configRuleName))
 
-		res, err := csr.Client.DescribeRemediationConfigurationsWithContext(csr.Context, &configservice.DescribeRemediationConfigurationsInput{
-			ConfigRuleNames: []*string{aws.String(configRuleName)},
+		res, err := csr.Client.DescribeRemediationConfigurations(csr.Context, &configservice.DescribeRemediationConfigurationsInput{
+			ConfigRuleNames: []string{configRuleName},
 		})
 		if err != nil {
 			pterm.Error.Println(fmt.Sprintf("Failed to describe remediation configurations w/ err %s", err))
@@ -63,7 +59,7 @@ func (csr *ConfigServiceRule) nukeAll(configRuleNames []string) error {
 		}
 
 		if len(res.RemediationConfigurations) > 0 {
-			_, err := csr.Client.DeleteRemediationConfigurationWithContext(csr.Context, &configservice.DeleteRemediationConfigurationInput{
+			_, err := csr.Client.DeleteRemediationConfiguration(csr.Context, &configservice.DeleteRemediationConfigurationInput{
 				ConfigRuleName: aws.String(configRuleName),
 			})
 			if err != nil {
@@ -81,7 +77,7 @@ func (csr *ConfigServiceRule) nukeAll(configRuleNames []string) error {
 		params := &configservice.DeleteConfigRuleInput{
 			ConfigRuleName: aws.String(configRuleName),
 		}
-		_, err = csr.Client.DeleteConfigRuleWithContext(csr.Context, params)
+		_, err = csr.Client.DeleteConfigRule(csr.Context, params)
 		if err != nil {
 			pterm.Error.Println(fmt.Sprintf("Failed to delete config rule w/ err %s", err))
 			report.Record(report.Entry{
diff --git a/aws/resources/config_service_types.go b/aws/resources/config_service_types.go
index d25d45e..e4f7fd7 100644
--- a/aws/resources/config_service_types.go
+++ b/aws/resources/config_service_types.go
@@ -3,25 +3,32 @@ 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/configservice"
-	"github.com/aws/aws-sdk-go/service/configservice/configserviceiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/configservice"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type ConfigServiceRuleAPI interface {
+	DescribeConfigRules(ctx context.Context, params *configservice.DescribeConfigRulesInput, optFns ...func(*configservice.Options)) (*configservice.DescribeConfigRulesOutput, error)
+	DescribeRemediationConfigurations(ctx context.Context, params *configservice.DescribeRemediationConfigurationsInput, optFns ...func(*configservice.Options)) (*configservice.DescribeRemediationConfigurationsOutput, error)
+	DeleteRemediationConfiguration(ctx context.Context, params *configservice.DeleteRemediationConfigurationInput, optFns ...func(*configservice.Options)) (*configservice.DeleteRemediationConfigurationOutput, error)
+	DeleteConfigRule(ctx context.Context, params *configservice.DeleteConfigRuleInput, optFns ...func(*configservice.Options)) (*configservice.DeleteConfigRuleOutput, error)
+}
+
 type ConfigServiceRule struct {
 	BaseAwsResource
-	Client    configserviceiface.ConfigServiceAPI
+	Client    ConfigServiceRuleAPI
 	Region    string
 	RuleNames []string
 }
 
-func (csr *ConfigServiceRule) Init(session *session.Session) {
-	csr.Client = configservice.New(session)
+func (csr *ConfigServiceRule) InitV2(cfg aws.Config) {
+	csr.Client = configservice.NewFromConfig(cfg)
 }
 
+func (csr *ConfigServiceRule) IsUsingV2() bool { return true }
+
 func (csr *ConfigServiceRule) ResourceName() string {
 	return "config-rules"
 }
@@ -44,7 +51,7 @@ func (csr *ConfigServiceRule) GetAndSetIdentifiers(c context.Context, configObj
 		return nil, err
 	}
 
-	csr.RuleNames = awsgo.StringValueSlice(identifiers)
+	csr.RuleNames = aws.ToStringSlice(identifiers)
 	return csr.RuleNames, nil
 }
 
diff --git a/aws/resources/datasync_location.go b/aws/resources/datasync_location.go
index c0608af..76c26cc 100644
--- a/aws/resources/datasync_location.go
+++ b/aws/resources/datasync_location.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/datasync"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/datasync"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -22,7 +22,7 @@ func (dsl *DataSyncLocation) nukeAll(identifiers []*string) error {
 
 	for _, identifier := range identifiers {
 		logging.Debugf("[Data Sync Location] Deleting Data Sync Location %s in region %s", *identifier, dsl.Region)
-		_, err := dsl.Client.DeleteLocationWithContext(dsl.Context, &datasync.DeleteLocationInput{
+		_, err := dsl.Client.DeleteLocation(dsl.Context, &datasync.DeleteLocationInput{
 			LocationArn: identifier,
 		})
 		if err != nil {
@@ -34,7 +34,7 @@ func (dsl *DataSyncLocation) nukeAll(identifiers []*string) error {
 		}
 
 		e := report.Entry{
-			Identifier:   aws.StringValue(identifier),
+			Identifier:   aws.ToString(identifier),
 			ResourceType: dsl.ResourceName(),
 			Error:        err,
 		}
@@ -47,21 +47,21 @@ func (dsl *DataSyncLocation) nukeAll(identifiers []*string) error {
 
 func (dsl *DataSyncLocation) getAll(c context.Context, _ config.Config) ([]*string, error) {
 	var identifiers []*string
-	paginator := func(output *datasync.ListLocationsOutput, lastPage bool) bool {
-		for _, location := range output.Locations {
-			identifiers = append(identifiers, location.LocationArn)
-		}
-
-		return !lastPage
-	}
-
 	param := &datasync.ListLocationsInput{
-		MaxResults: aws.Int64(100),
+		MaxResults: aws.Int32(100),
 	}
 
-	if err := dsl.Client.ListLocationsPagesWithContext(c, param, paginator); err != nil {
-		logging.Debugf("[Data Sync Location] Failed to list Data Sync Locations: %s", err)
-		return nil, errors.WithStackTrace(err)
+	locationsPaginator := datasync.NewListLocationsPaginator(dsl.Client, param)
+	for locationsPaginator.HasMorePages() {
+		output, err := locationsPaginator.NextPage(c)
+		if err != nil {
+			logging.Debugf("[Data Sync Location] Failed to list Data Sync Locations: %s", err)
+			return nil, errors.WithStackTrace(err)
+		}
+
+		for _, location := range output.Locations {
+			identifiers = append(identifiers, location.LocationArn)
+		}
 	}
 
 	return identifiers, nil
diff --git a/aws/resources/datasync_location_types.go b/aws/resources/datasync_location_types.go
index c8292c9..314a77f 100644
--- a/aws/resources/datasync_location_types.go
+++ b/aws/resources/datasync_location_types.go
@@ -3,17 +3,20 @@ 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/datasync"
-	"github.com/aws/aws-sdk-go/service/datasync/datasynciface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/datasync"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type DataSyncLocationAPI interface {
+	DeleteLocation(ctx context.Context, params *datasync.DeleteLocationInput, optFns ...func(*datasync.Options)) (*datasync.DeleteLocationOutput, error)
+	ListLocations(ctx context.Context, params *datasync.ListLocationsInput, optFns ...func(*datasync.Options)) (*datasync.ListLocationsOutput, error)
+}
+
 type DataSyncLocation struct {
 	BaseAwsResource
-	Client            datasynciface.DataSyncAPI
+	Client            DataSyncLocationAPI
 	Region            string
 	DataSyncLocations []string
 }
@@ -22,10 +25,12 @@ func (dsl *DataSyncLocation) GetAndSetResourceConfig(configObj config.Config) co
 	return configObj.DataSyncLocation
 }
 
-func (dsl *DataSyncLocation) Init(session *session.Session) {
-	dsl.Client = datasync.New(session)
+func (dsl *DataSyncLocation) InitV2(cfg aws.Config) {
+	dsl.Client = datasync.NewFromConfig(cfg)
 }
 
+func (dsl *DataSyncLocation) IsUsingV2() bool { return true }
+
 func (dsl *DataSyncLocation) ResourceName() string { return "data-sync-location" }
 
 func (dsl *DataSyncLocation) ResourceIdentifiers() []string { return dsl.DataSyncLocations }
@@ -46,6 +51,6 @@ func (dsl *DataSyncLocation) GetAndSetIdentifiers(c context.Context, configObj c
 		return nil, err
 	}
 
-	dsl.DataSyncLocations = aws.StringValueSlice(identifiers)
+	dsl.DataSyncLocations = aws.ToStringSlice(identifiers)
 	return dsl.DataSyncLocations, nil
 }
diff --git a/aws/resources/datasync_task.go b/aws/resources/datasync_task.go
index 4521d7d..c5dfaca 100644
--- a/aws/resources/datasync_task.go
+++ b/aws/resources/datasync_task.go
@@ -3,8 +3,8 @@ package resources
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/datasync"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/datasync"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -22,7 +22,7 @@ func (dst *DataSyncTask) nukeAll(identifiers []*string) error {
 
 	for _, identifier := range identifiers {
 		logging.Debugf("[Data Sync Task] Deleting Data Sync Task %s in region %s", *identifier, dst.Region)
-		_, err := dst.Client.DeleteTaskWithContext(dst.Context, &datasync.DeleteTaskInput{
+		_, err := dst.Client.DeleteTask(dst.Context, &datasync.DeleteTaskInput{
 			TaskArn: identifier,
 		})
 		if err != nil {
@@ -34,7 +34,7 @@ func (dst *DataSyncTask) nukeAll(identifiers []*string) error {
 		}
 
 		e := report.Entry{
-			Identifier:   aws.StringValue(identifier),
+			Identifier:   aws.ToString(identifier),
 			ResourceType: dst.ResourceName(),
 			Error:        err,
 		}
@@ -47,7 +47,18 @@ func (dst *DataSyncTask) nukeAll(identifiers []*string) error {
 
 func (dst *DataSyncTask) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var identifiers []*string
-	paginator := func(output *datasync.ListTasksOutput, lastPage bool) bool {
+	param := &datasync.ListTasksInput{
+		MaxResults: aws.Int32(100),
+	}
+
+	tasksPaginator := datasync.NewListTasksPaginator(dst.Client, param)
+	for tasksPaginator.HasMorePages() {
+		output, err := tasksPaginator.NextPage(c)
+		if err != nil {
+			logging.Debugf("[Data Sync Task] Failed to list data sync tasks: %s", err)
+			return nil, errors.WithStackTrace(err)
+		}
+
 		for _, task := range output.Tasks {
 			if configObj.DataSyncTask.ShouldInclude(config.ResourceValue{
 				Name: task.Name,
@@ -55,17 +66,6 @@ func (dst *DataSyncTask) getAll(c context.Context, configObj config.Config) ([]*
 				identifiers = append(identifiers, task.TaskArn)
 			}
 		}
-
-		return !lastPage
-	}
-
-	param := &datasync.ListTasksInput{
-		MaxResults: aws.Int64(100),
-	}
-
-	if err := dst.Client.ListTasksPagesWithContext(c, param, paginator); err != nil {
-		logging.Debugf("[Data Sync Task] Failed to list data sync tasks: %s", err)
-		return nil, errors.WithStackTrace(err)
 	}
 
 	return identifiers, nil
diff --git a/aws/resources/datasync_task_types.go b/aws/resources/datasync_task_types.go
index 0827821..780f9d5 100644
--- a/aws/resources/datasync_task_types.go
+++ b/aws/resources/datasync_task_types.go
@@ -3,17 +3,20 @@ 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/datasync"
-	"github.com/aws/aws-sdk-go/service/datasync/datasynciface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/datasync"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
+type DataSyncTaskAPI interface {
+	DeleteTask(ctx context.Context, params *datasync.DeleteTaskInput, optFns ...func(*datasync.Options)) (*datasync.DeleteTaskOutput, error)
+	ListTasks(ctx context.Context, params *datasync.ListTasksInput, optFns ...func(*datasync.Options)) (*datasync.ListTasksOutput, error)
+}
+
 type DataSyncTask struct {
 	BaseAwsResource
-	Client        datasynciface.DataSyncAPI
+	Client        DataSyncTaskAPI
 	Region        string
 	DataSyncTasks []string
 }
@@ -22,10 +25,12 @@ func (dst *DataSyncTask) GetAndSetResourceConfig(configObj config.Config) config
 	return configObj.DataSyncTask
 }
 
-func (dst *DataSyncTask) Init(session *session.Session) {
-	dst.Client = datasync.New(session)
+func (dst *DataSyncTask) InitV2(cfg aws.Config) {
+	dst.Client = datasync.NewFromConfig(cfg)
 }
 
+func (dst *DataSyncTask) IsUsingV2() bool { return true }
+
 func (dst *DataSyncTask) ResourceName() string { return "data-sync-task" }
 
 func (dst *DataSyncTask) ResourceIdentifiers() []string { return dst.DataSyncTasks }
@@ -46,6 +51,6 @@ func (dst *DataSyncTask) GetAndSetIdentifiers(c context.Context, configObj confi
 		return nil, err
 	}
 
-	dst.DataSyncTasks = aws.StringValueSlice(identifiers)
+	dst.DataSyncTasks = aws.ToStringSlice(identifiers)
 	return dst.DataSyncTasks, nil
 }
diff --git a/aws/resources/dynamodb.go b/aws/resources/dynamodb.go
index 6075191..4fe83b9 100644
--- a/aws/resources/dynamodb.go
+++ b/aws/resources/dynamodb.go
@@ -4,9 +4,8 @@ import (
 	"context"
 	"log"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/logging"
 	"github.com/gruntwork-io/cloud-nuke/report"
@@ -16,28 +15,26 @@ import (
 func (ddb *DynamoDB) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	var tableNames []*string
 
-	err := ddb.Client.ListTablesPagesWithContext(
-		ddb.Context,
-		&dynamodb.ListTablesInput{}, func(page *dynamodb.ListTablesOutput, lastPage bool) bool {
-			for _, table := range page.TableNames {
-				tableDetail, err := ddb.Client.DescribeTableWithContext(ddb.Context, &dynamodb.DescribeTableInput{TableName: table})
-				if err != nil {
-					log.Fatalf("There was an error describing table: %v\n", err)
-				}
+	paginator := dynamodb.NewListTablesPaginator(ddb.Client, &dynamodb.ListTablesInput{})
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(c)
+		if err != nil {
+			return nil, err
+		}
 
-				if configObj.DynamoDB.ShouldInclude(config.ResourceValue{
-					Time: tableDetail.Table.CreationDateTime,
-					Name: tableDetail.Table.TableName,
-				}) {
-					tableNames = append(tableNames, table)
-				}
+		for _, table := range page.TableNames {
+			tableDetail, errPage := ddb.Client.DescribeTable(ddb.Context, &dynamodb.DescribeTableInput{TableName: aws.String(table)})
+			if errPage != nil {
+				log.Fatalf("There was an error describing table: %v\n", errPage)
 			}
 
-			return !lastPage
-		})
-
-	if err != nil {
-		return nil, err
+			if configObj.DynamoDB.ShouldInclude(config.ResourceValue{
+				Time: tableDetail.Table.CreationDateTime,
+				Name: tableDetail.Table.TableName,
+			}) {
+				tableNames = append(tableNames, aws.String(table))
+			}
+		}
 	}
 
 	return tableNames, nil
@@ -55,25 +52,18 @@ func (ddb *DynamoDB) nukeAll(tables []*string) error {
 		input := &dynamodb.DeleteTableInput{
 			TableName: aws.String(*table),
 		}
-		_, err := ddb.Client.DeleteTableWithContext(ddb.Context, input)
+		_, err := ddb.Client.DeleteTable(ddb.Context, input)
 
 		// Record status of this resource
 		e := report.Entry{
-			Identifier:   aws.StringValue(table),
+			Identifier:   aws.ToString(table),
 			ResourceType: "DynamoDB Table",
 			Error:        err,
 		}
 		report.Record(e)
 
 		if err != nil {
-			if aerr, ok := err.(awserr.Error); ok {
-				switch aerr.Error() {
-				case dynamodb.ErrCodeInternalServerError:
-					return errors.WithStackTrace(aerr)
-				default:
-					return errors.WithStackTrace(aerr)
-				}
-			}
+			return errors.WithStackTrace(err)
 		}
 	}
 	return nil
diff --git a/aws/resources/dynamodb_types.go b/aws/resources/dynamodb_types.go
index 584c1b1..c39f924 100644
--- a/aws/resources/dynamodb_types.go
+++ b/aws/resources/dynamodb_types.go
@@ -3,25 +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/dynamodb"
-	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/gruntwork-cli/errors"
 )
 
+type DynamoDBAPI interface {
+	ListTables(ctx context.Context, params *dynamodb.ListTablesInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ListTablesOutput, error)
+	DescribeTable(ctx context.Context, params *dynamodb.DescribeTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DescribeTableOutput, error)
+	DeleteTable(ctx context.Context, params *dynamodb.DeleteTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DeleteTableOutput, error)
+}
+
 type DynamoDB struct {
 	BaseAwsResource
-	Client           dynamodbiface.DynamoDBAPI
+	Client           DynamoDBAPI
 	Region           string
 	DynamoTableNames []string
 }
 
-func (ddb *DynamoDB) Init(session *session.Session) {
-	ddb.Client = dynamodb.New(session)
+func (ddb *DynamoDB) InitV2(cfg aws.Config) {
+	ddb.Client = dynamodb.NewFromConfig(cfg)
 }
 
+func (ddb *DynamoDB) IsUsingV2() bool { return true }
+
 func (ddb *DynamoDB) ResourceName() string {
 	return "dynamodb"
 }
@@ -45,13 +51,13 @@ func (ddb *DynamoDB) GetAndSetIdentifiers(c context.Context, configObj config.Co
 		return nil, err
 	}
 
-	ddb.DynamoTableNames = awsgo.StringValueSlice(identifiers)
+	ddb.DynamoTableNames = aws.ToStringSlice(identifiers)
 	return ddb.DynamoTableNames, nil
 }
 
 // Nuke - nuke all Dynamo DB Tables
 func (ddb *DynamoDB) Nuke(identifiers []string) error {
-	if err := ddb.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+	if err := ddb.nukeAll(aws.StringSlice(identifiers)); err != nil {
 		return errors.WithStackTrace(err)
 	}
 	return nil
diff --git a/go.mod b/go.mod
index 845ed7e..b222f9b 100644
--- a/go.mod
+++ b/go.mod
@@ -7,7 +7,22 @@ require (
 	github.com/aws/aws-sdk-go-v2 v1.32.2
 	github.com/aws/aws-sdk-go-v2/config v1.27.24
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.24
+	github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.2
+	github.com/aws/aws-sdk-go-v2/service/acm v1.30.2
+	github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.3
 	github.com/aws/aws-sdk-go-v2/service/amp v1.27.1
+	github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.2
+	github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.2
+	github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.2
+	github.com/aws/aws-sdk-go-v2/service/autoscaling v1.23.16
+	github.com/aws/aws-sdk-go-v2/service/backup v1.39.3
+	github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.2
+	github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.2
+	github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.42.0
+	github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.2
+	github.com/aws/aws-sdk-go-v2/service/configservice v1.50.2
+	github.com/aws/aws-sdk-go-v2/service/datasync v1.42.2
+	github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.2
 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.184.0
 	github.com/aws/aws-sdk-go-v2/service/eventbridge v1.33.7
 	github.com/aws/aws-sdk-go-v2/service/scheduler v1.10.7
@@ -28,12 +43,14 @@ require (
 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.9 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.17 // 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.2 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sso v1.22.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.2 // indirect
diff --git a/go.sum b/go.sum
index 8996396..2df989e 100644
--- a/go.sum
+++ b/go.sum
@@ -15,44 +15,67 @@ 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.16.7/go.mod h1:6CpKuLXg2w7If3ABZCl/qZ6rEgwtjZTn4eAf4RcEyuw=
+github.com/aws/aws-sdk-go-v2 v1.16.16/go.mod h1:SwiyXi/1zTUZ6KIAmLK5V5ll8SiURNUYOqTerZPaF9k=
 github.com/aws/aws-sdk-go-v2 v1.32.2 h1:AkNLZEyYMLnx/Q/mSKkcMqwNFXMAvFto9bNsHqcTduI=
 github.com/aws/aws-sdk-go-v2 v1.32.2/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.27.24 h1:NM9XicZ5o1CBU/MZaHwFtimRpWx9ohAUAqkG6AqSqPo=
 github.com/aws/aws-sdk-go-v2/config v1.27.24/go.mod h1:aXzi6QJTuQRVVusAO8/NxpdTeTyr/wRcybdDtfUwJSs=
 github.com/aws/aws-sdk-go-v2/credentials v1.17.24 h1:YclAsrnb1/GTQNt2nzv+756Iw4mF8AOzcDfweWwwm/M=
 github.com/aws/aws-sdk-go-v2/credentials v1.17.24/go.mod h1:Hld7tmnAkoBQdTMNYZGzztzKRdA4fCdn9L83LOoigac=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.9 h1:Aznqksmd6Rfv2HQN9cpqIV/lQRMaIpJkLLaJ1ZI76no=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.9/go.mod h1:WQr3MY7AxGNxaqAtsDWn+fBxmd4XvLkzeqQ8P1VM0/w=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.14/go.mod h1:kdjrMwHwrC3+FsKhNcCMJ7tUVj/8uSD5CZXeQ4wV6fM=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18 h1:kYQ3H1u0ANr9KEKlGs/jTLrBFPo8P8NaH/w7A01NeeM=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18/go.mod h1:r506HmK5JDUh9+Mw4CfGJGSSoqIiLCndAuqXuhbv67Y=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.23/go.mod h1:2DFxAQ9pfIRy0imBCJv+vZ2X6RKxves6fbnEuSry6b4=
 github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21 h1:UAsR3xA31QGf79WzpG/ixT9FZvQlh5HY1NRqSHBNOCk=
 github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21/go.mod h1:JNr43NFf5L9YaG3eKTm7HQzls9J+A9YYcGI5Quh1r2Y=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.8/go.mod h1:ZIV8GYoC6WLBW5KGs+o4rsc65/ozd+eQ0L31XF5VDwk=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18 h1:Z7IdFUONvTcvS7YuhtVxN99v2cCoHRXOS4mTr0B/pUc=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18/go.mod h1:DkKMmksZVVyat+Y+r1dEOgJEfUeA7UngIHWeKsi0yNc=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.17/go.mod h1:pRwaTYCJemADaqCbUAxltMoHKata7hmB5PjEXeu0kfg=
 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21 h1:6jZVETqmYCadGFvrYEQfC5fAQmlo80CeL5psbno6r0s=
 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21/go.mod h1:1SR0GbLlnN3QUmYaflZNiH1ql+1qrSiB2vwcJ+4UM60=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.17 h1:Roo69qTpfu8OlJ2Tb7pAYVuF0CpuUMB0IYWwYP/4DZM=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.17/go.mod h1:NcWPxQzGM1USQggaTVwz6VpqMZPX1CvDJLDh6jnOCa4=
+github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.2 h1:QliYfQlWPSjTZpLjj8dXpV6jRuxMs9DFJ8W1Q+ZHMy8=
+github.com/aws/aws-sdk-go-v2/service/accessanalyzer v1.34.2/go.mod h1:9bHRHmhoqatAujuRir347sJaGEg6xoV0T3On4DNiJ10=
+github.com/aws/aws-sdk-go-v2/service/acm v1.30.2 h1:LNCRNr5Ha6OUcnV4licXm/V9/fUyto85nQdQSscC09g=
+github.com/aws/aws-sdk-go-v2/service/acm v1.30.2/go.mod h1:wRBzxEW2vsJMJAuV7yWEHGzo/KycX3t02mUVm6P8qHY=
+github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.3 h1:1jmLDJJ3StvfOopWDb/HY9mDSN2e7ZmReww4FTFvNnU=
+github.com/aws/aws-sdk-go-v2/service/acmpca v1.37.3/go.mod h1:vWSvubH4BhEG1Vl6lLUVHZzRo7lgIM7/oJpBv6hN5i4=
 github.com/aws/aws-sdk-go-v2/service/amp v1.27.1 h1:va9j7MGA8jBlQs9KujMlkSdnC26TuEJXv7ywnFjmTZ8=
 github.com/aws/aws-sdk-go-v2/service/amp v1.27.1/go.mod h1:QhmX7qjomjuHJjCJbW+QRdaCBM42v1eAbWvBVFrT1Vw=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.47.2 h1:81hrDgbXHL44WdY6M/fHGXLlv17qTpOFzutXRVDEk3Y=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.47.2/go.mod h1:VoBcwURHnJVCWuXHdqVuG03i2lUlHJ5DTTqDSyCdEcc=
+github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.2 h1:XMdSPyg1ZJsoPIhmOiiSSA4qsk/G2ZGgDNYp3JQOwzk=
+github.com/aws/aws-sdk-go-v2/service/apigateway v1.27.2/go.mod h1:dxPkh3eysV7j4JJqodTQijVKlIH0A3MhGJcQpJO1XL4=
+github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.2 h1:dLg685y7wusZZjJcZ+c0PhV8+wjTn1xzidvUkondtJM=
+github.com/aws/aws-sdk-go-v2/service/apigatewayv2 v1.24.2/go.mod h1:wwTm1f7PQvrhoXmvPiqalPJ3tUfA5p4TaBs4pu3yOYs=
+github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.2 h1:468DHZ8HOxmnyc+FPHrA12mIiBLm/TAKrn2AQDLeiTw=
+github.com/aws/aws-sdk-go-v2/service/apprunner v1.32.2/go.mod h1:MFQKKPZwSPqOvqDnf9dqobSKODpgqnnbhYYzE3QAgDM=
+github.com/aws/aws-sdk-go-v2/service/autoscaling v1.23.16 h1:cp30gVVAbZfeDod6UJGppMH2+p+/cRCG2AZ1TbT+LqA=
+github.com/aws/aws-sdk-go-v2/service/autoscaling v1.23.16/go.mod h1:hHTMeJt6CQwFdmS19RK1LsDscus8c25Ve8KiYRhsISg=
+github.com/aws/aws-sdk-go-v2/service/backup v1.39.3 h1:mjYDN7CPl0CHrTBe36EKqAAGGXAKy8MXuNF+2qHkVdM=
+github.com/aws/aws-sdk-go-v2/service/backup v1.39.3/go.mod h1:dc18UjjmJLlpcPGF6kluQcEpcddqlkdRTF8h5XKWSbc=
+github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.2 h1:0RsL6IlPHeAgl6RF0gGIlB4OKIw3rjfNrueOMj8qELg=
+github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.44.2/go.mod h1:0tPpvgvHOBqIh+j0s5GL+WzrAevuxVJOEQC2GF2CJvo=
+github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.2 h1:eMh+iBTF1CbpHMfiRvIaVm+rzrH1DOzuSFaR55O+bBo=
+github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.42.2/go.mod h1:/A4zNqF1+RS5RV+NNLKIzUX1KtK5SoWgf/OpiqrwmBo=
+github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.42.0 h1:LM/Ij1aUUeqRTEJPm5kLLcougWLKDSvZE3P4OGB5P8c=
+github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.42.0/go.mod h1:+/4cU1i0DF9gaA6GAZRIHVJWLZB7SSqJTCvkOMilNQE=
+github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.2 h1:sVFvCVQ5E3b2Wqh2gBnUfIinw7NdJ7h9d1kdGBV6LYE=
+github.com/aws/aws-sdk-go-v2/service/codedeploy v1.29.2/go.mod h1:Y2cnvaNeBNgLOvDSBi2zGy8ft9eR7qBKbxCLgR4O5yI=
+github.com/aws/aws-sdk-go-v2/service/configservice v1.50.2 h1:snWKvHjE6VO/YpqkcEgogVCrcyczOJx/hyyn2g05n1I=
+github.com/aws/aws-sdk-go-v2/service/configservice v1.50.2/go.mod h1:+J+fFPZtXSJoSYFKI0LSjNPZ4bN1kPErZOldY/Z7QHM=
+github.com/aws/aws-sdk-go-v2/service/datasync v1.42.2 h1:mNOyYZFjd3CakcvYIVCmqXFZ0pZJSGobtDx5UciBLOc=
+github.com/aws/aws-sdk-go-v2/service/datasync v1.42.2/go.mod h1:qWAvIKfkNqX/IN0sXwOiq73zzSCW/Ar96mHbfY/5D9c=
+github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.2 h1:kJqyYcGqhWFmXqjRrtFFD4Oc9FXiskhsll2xnlpe8Do=
+github.com/aws/aws-sdk-go-v2/service/dynamodb v1.36.2/go.mod h1:+t2Zc5VNOzhaWzpGE+cEYZADsgAAQT5v55AO+fhU+2s=
 github.com/aws/aws-sdk-go-v2/service/ec2 v1.184.0 h1:SZnuDlml1uFv5ojh+QTxS+Yru89Hr3QYIUwWoY71frI=
 github.com/aws/aws-sdk-go-v2/service/ec2 v1.184.0/go.mod h1:kYXaB4FzyhEJjvrJ84oPnMElLiEAjGxxUunVW2tBSng=
 github.com/aws/aws-sdk-go-v2/service/eventbridge v1.33.7 h1:q+xiPu+Dk5MFC20ZjdGGhbihD39Xsih98epvVjnOjyE=
 github.com/aws/aws-sdk-go-v2/service/eventbridge v1.33.7/go.mod h1:iQCsmx9LyBMyMEkLCBVqnIAz+rfo6/ss3oLcYn26+no=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3 h1:dT3MqvGhSoaIhRseqw2I0yH81l7wiR2vjs57O51EAm8=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3/go.mod h1:GlAeCkHwugxdHaueRr4nhPuY+WW+gR8UjlcqzPr1SPI=
 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/presigned-url v1.9.8/go.mod h1:rDVhIMAX9N2r8nWxDUlbubvvaFMnfsm+3jAV7q+rpM4=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.15 h1:I9zMeF107l0rJrpnHpjEiiTSCKYAIw8mALiXcPsGBiA=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.15/go.mod h1:9xWJ3Q/S6Ojusz1UIkfycgD1mGirJfLLKqq3LPT7WN8=
+github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.2 h1:1G7TTQNPNv5fhCyIQGYk8FOggLgkzKq6c4Y1nOGzAOE=
+github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.10.2/go.mod h1:+ybYGLXoF7bcD7wIcMcklxyABZQmuBf1cHUhvY6FGIo=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2 h1:s7NA1SOw8q/5c0wr8477yOPp0z+uBaXBnLE0XYb0POA=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2/go.mod h1:fnjjWyAW/Pj5HYOxl9LJqWtEwS7W2qgcRLWP+uWbss0=
 github.com/aws/aws-sdk-go-v2/service/scheduler v1.10.7 h1:EcPyKUUo3neD2tDFKnq3TR3B9s2uZe9eWgxVQgixdzc=
@@ -67,7 +90,7 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.2 h1:ORnrOK0C4WmYV/uYt3koHEWB
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.2/go.mod h1:xyFHA4zGxgYkdD73VeezHt3vSKEG9EmFnGwoKlP00u4=
 github.com/aws/aws-sdk-go-v2/service/sts v1.30.1 h1:+woJ607dllHJQtsnJLi52ycuqHMwlW+Wqm2Ppsfp4nQ=
 github.com/aws/aws-sdk-go-v2/service/sts v1.30.1/go.mod h1:jiNR3JqT15Dm+QWq2SRgh0x0bCNSRP2L25+CqPNpJlQ=
-github.com/aws/smithy-go v1.12.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA=
+github.com/aws/smithy-go v1.13.3/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA=
 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/util/tag.go b/util/tag.go
index 5a4b7b6..5a9e659 100644
--- a/util/tag.go
+++ b/util/tag.go
@@ -1,8 +1,8 @@
 package util
 
 import (
+	autoscaling "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/aws/aws-sdk-go/service/networkfirewall"
@@ -37,7 +37,7 @@ func ConvertTypesTagsToMap(tags []types.Tag) map[string]string {
 	return tagMap
 }
 
-func ConvertAutoScalingTagsToMap(tags []*autoscaling.TagDescription) map[string]string {
+func ConvertAutoScalingTagsToMap(tags []autoscaling.TagDescription) map[string]string {
 	tagMap := make(map[string]string)
 	for _, tag := range tags {
 		tagMap[*tag.Key] = *tag.Value
diff --git a/v2_migration_report/output.md b/v2_migration_report/output.md
index 7b2e245..d350292 100644
--- a/v2_migration_report/output.md
+++ b/v2_migration_report/output.md
@@ -6,25 +6,25 @@ run `go generate ./...` to refresh this report.
 
 | Resource Name                    | Migrated           |
 |----------------------------------|--------------------|
-| accessanalyzer                   |                    |
-| acm                              |                    |
-| acmpca                           |                    |
-| ami                              |                    |
-| apigateway                       |                    |
-| apigatewayv2                     |                    |
-| app-runner-service               |                    |
-| asg                              |                    |
-| backup-vault                     |                    |
-| cloudtrail                       |                    |
-| cloudwatch-alarm                 |                    |
-| cloudwatch-dashboard             |                    |
-| cloudwatch-loggroup              |                    |
-| codedeploy-application           |                    |
-| config-recorders                 |                    |
-| config-rules                     |                    |
-| data-sync-location               |                    |
-| data-sync-task                   |                    |
-| dynamodb                         |                    |
+| accessanalyzer                   | :white_check_mark: |
+| acm                              | :white_check_mark: |
+| acmpca                           | :white_check_mark: |
+| ami                              | :white_check_mark: |
+| apigateway                       | :white_check_mark: |
+| apigatewayv2                     | :white_check_mark: |
+| app-runner-service               | :white_check_mark: |
+| asg                              | :white_check_mark: |
+| backup-vault                     | :white_check_mark: |
+| cloudtrail                       | :white_check_mark: |
+| cloudwatch-alarm                 | :white_check_mark: |
+| cloudwatch-dashboard             | :white_check_mark: |
+| cloudwatch-loggroup              | :white_check_mark: |
+| codedeploy-application           | :white_check_mark: |
+| config-recorders                 | :white_check_mark: |
+| config-rules                     | :white_check_mark: |
+| data-sync-location               | :white_check_mark: |
+| data-sync-task                   | :white_check_mark: |
+| dynamodb                         | :white_check_mark: |
 | ebs                              |                    |
 | ec2                              |                    |
 | ec2-dedicated-hosts              |                    |


Test patch:
diff --git a/aws/resources/access_analyzer_test.go b/aws/resources/access_analyzer_test.go
index f4a36cf..16bd254 100644
--- a/aws/resources/access_analyzer_test.go
+++ b/aws/resources/access_analyzer_test.go
@@ -7,31 +7,27 @@ 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/accessanalyzer"
-	"github.com/aws/aws-sdk-go/service/accessanalyzer/accessanalyzeriface"
+	"github.com/aws/aws-sdk-go-v2/service/accessanalyzer"
+	"github.com/aws/aws-sdk-go-v2/service/accessanalyzer/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedAccessAnalyzer struct {
-	accessanalyzeriface.AccessAnalyzerAPI
-	ListAnalyzersPagesOutput accessanalyzer.ListAnalyzersOutput
-	DeleteAnalyzerOutput     accessanalyzer.DeleteAnalyzerOutput
+	AccessAnalyzerAPI
+	ListAnalyzersOutput  accessanalyzer.ListAnalyzersOutput
+	DeleteAnalyzerOutput accessanalyzer.DeleteAnalyzerOutput
 }
 
-func (m mockedAccessAnalyzer) ListAnalyzersPagesWithContext(_ awsgo.Context, _ *accessanalyzer.ListAnalyzersInput, callback func(*accessanalyzer.ListAnalyzersOutput, bool) bool, _ ...request.Option) error {
-	callback(&m.ListAnalyzersPagesOutput, true)
-	return nil
+func (m mockedAccessAnalyzer) ListAnalyzers(context.Context, *accessanalyzer.ListAnalyzersInput, ...func(*accessanalyzer.Options)) (*accessanalyzer.ListAnalyzersOutput, error) {
+	return &m.ListAnalyzersOutput, nil
 }
 
-func (m mockedAccessAnalyzer) DeleteAnalyzerWithContext(awsgo.Context, *accessanalyzer.DeleteAnalyzerInput, ...request.Option) (*accessanalyzer.DeleteAnalyzerOutput, error) {
+func (m mockedAccessAnalyzer) DeleteAnalyzer(ctx context.Context, params *accessanalyzer.DeleteAnalyzerInput, optFns ...func(*accessanalyzer.Options)) (*accessanalyzer.DeleteAnalyzerOutput, error) {
 	return &m.DeleteAnalyzerOutput, nil
 }
 
 func TestAccessAnalyzer_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	now := time.Now()
@@ -39,15 +35,15 @@ func TestAccessAnalyzer_GetAll(t *testing.T) {
 	testName2 := "test2"
 	aa := AccessAnalyzer{
 		Client: mockedAccessAnalyzer{
-			ListAnalyzersPagesOutput: accessanalyzer.ListAnalyzersOutput{
-				Analyzers: []*accessanalyzer.AnalyzerSummary{
+			ListAnalyzersOutput: accessanalyzer.ListAnalyzersOutput{
+				Analyzers: []types.AnalyzerSummary{
 					{
-						Name:      awsgo.String(testName1),
-						CreatedAt: awsgo.Time(now),
+						Name:      aws.String(testName1),
+						CreatedAt: aws.Time(now),
 					},
 					{
-						Name:      awsgo.String(testName2),
-						CreatedAt: awsgo.Time(now.Add(1)),
+						Name:      aws.String(testName2),
+						CreatedAt: aws.Time(now.Add(1)),
 					},
 				},
 			},
@@ -79,20 +75,19 @@ func TestAccessAnalyzer_GetAll(t *testing.T) {
 			expected: []string{testName1},
 		},
 	}
+
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			names, err := aa.getAll(context.Background(), config.Config{
 				AccessAnalyzer: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, awsgo.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
-
 }
 
 func TestAccessAnalyzer_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	aa := AccessAnalyzer{
@@ -101,6 +96,6 @@ func TestAccessAnalyzer_NukeAll(t *testing.T) {
 		},
 	}
 
-	err := aa.nukeAll([]*string{awsgo.String("test")})
+	err := aa.nukeAll([]*string{aws.String("test")})
 	require.NoError(t, err)
 }
diff --git a/aws/resources/acm_test.go b/aws/resources/acm_test.go
index 0bd4a74..9dc7277 100644
--- a/aws/resources/acm_test.go
+++ b/aws/resources/acm_test.go
@@ -6,46 +6,37 @@ 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/acm"
-	"github.com/aws/aws-sdk-go/service/acm/acmiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/acm"
+	"github.com/aws/aws-sdk-go-v2/service/acm/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedACM struct {
-	acmiface.ACMAPI
-	ListCertificatesOutput  acm.ListCertificatesOutput
+	ACMServiceAPI
 	DeleteCertificateOutput acm.DeleteCertificateOutput
+	ListCertificatesOutput  acm.ListCertificatesOutput
 }
 
-func (m mockedACM) ListCertificatesPagesWithContext(
-	_ aws.Context,
-	_ *acm.ListCertificatesInput,
-	fn func(*acm.ListCertificatesOutput, bool) bool,
-	_ ...request.Option,
-) error {
-	// Only need to return mocked response output
-	fn(&m.ListCertificatesOutput, true)
-	return nil
+func (m mockedACM) ListCertificates(ctx context.Context, params *acm.ListCertificatesInput, optFns ...func(*acm.Options)) (*acm.ListCertificatesOutput, error) {
+	return &m.ListCertificatesOutput, nil
 }
 
-func (m mockedACM) DeleteCertificateWithContext(_ aws.Context, input *acm.DeleteCertificateInput, _ ...request.Option) (*acm.DeleteCertificateOutput, error) {
+func (m mockedACM) DeleteCertificate(ctx context.Context, params *acm.DeleteCertificateInput, optFns ...func(*acm.Options)) (*acm.DeleteCertificateOutput, error) {
 	return &m.DeleteCertificateOutput, nil
 }
 
 func TestACMGetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testDomainName := "test-domain-name"
 	testArn := "test-arn"
 	now := time.Now()
-	acm := ACM{
+	acmService := ACM{
 		Client: mockedACM{
 			ListCertificatesOutput: acm.ListCertificatesOutput{
-				CertificateSummaryList: []*acm.CertificateSummary{
+				CertificateSummaryList: []types.CertificateSummary{
 					{
 						DomainName:     &testDomainName,
 						CreatedAt:      &now,
@@ -57,12 +48,12 @@ func TestACMGetAll(t *testing.T) {
 	}
 
 	// without any filters
-	acms, err := acm.getAll(context.Background(), config.Config{})
+	acms, err := acmService.getAll(context.Background(), config.Config{})
 	require.NoError(t, err)
-	require.Contains(t, aws.StringValueSlice(acms), testArn)
+	require.Contains(t, aws.ToStringSlice(acms), testArn)
 
 	// filtering domain names
-	acms, err = acm.getAll(context.Background(), config.Config{
+	acms, err = acmService.getAll(context.Background(), config.Config{
 		ACM: config.ResourceType{
 			ExcludeRule: config.FilterRule{
 				NamesRegExp: []config.Expression{{
@@ -70,29 +61,28 @@ func TestACMGetAll(t *testing.T) {
 				}}}},
 	})
 	require.NoError(t, err)
-	require.NotContains(t, aws.StringValueSlice(acms), testArn)
+	require.NotContains(t, aws.ToStringSlice(acms), testArn)
 
 	// filtering with time
-	acms, err = acm.getAll(context.Background(), config.Config{
+	acms, err = acmService.getAll(context.Background(), config.Config{
 		ACM: config.ResourceType{
 			ExcludeRule: config.FilterRule{
 				TimeAfter: aws.Time(now.Add(-1)),
 			}},
 	})
 	require.NoError(t, err)
-	require.NotContains(t, aws.StringValueSlice(acms), testArn)
+	require.NotContains(t, aws.ToStringSlice(acms), testArn)
 }
 
 func TestACMGetAll_FilterInUse(t *testing.T) {
-
 	t.Parallel()
 
 	testDomainName := "test-domain-name"
 	testArn := "test-arn"
-	acm := ACM{
+	acmService := ACM{
 		Client: mockedACM{
 			ListCertificatesOutput: acm.ListCertificatesOutput{
-				CertificateSummaryList: []*acm.CertificateSummary{
+				CertificateSummaryList: []types.CertificateSummary{
 					{
 						DomainName:     &testDomainName,
 						InUse:          aws.Bool(true),
@@ -103,22 +93,21 @@ func TestACMGetAll_FilterInUse(t *testing.T) {
 		},
 	}
 
-	acms, err := acm.getAll(context.Background(), config.Config{})
+	acms, err := acmService.getAll(context.Background(), config.Config{})
 	require.NoError(t, err)
 	require.NotContains(t, acms, testArn)
 }
 
 func TestACMNukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testDomainName := "test-domain-name"
-	acm := ACM{
+	acmService := ACM{
 		Client: mockedACM{
 			DeleteCertificateOutput: acm.DeleteCertificateOutput{},
 		},
 	}
 
-	err := acm.nukeAll([]*string{&testDomainName})
+	err := acmService.nukeAll([]*string{&testDomainName})
 	require.NoError(t, err)
 }
diff --git a/aws/resources/acmpca_test.go b/aws/resources/acmpca_test.go
index 1b2ef95..2bb758b 100644
--- a/aws/resources/acmpca_test.go
+++ b/aws/resources/acmpca_test.go
@@ -5,43 +5,38 @@ 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/acmpca"
-	"github.com/aws/aws-sdk-go/service/acmpca/acmpcaiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/acmpca"
+	"github.com/aws/aws-sdk-go-v2/service/acmpca/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedACMPCA struct {
-	acmpcaiface.ACMPCAAPI
-	ListCertificateAuthoritiesOutput   acmpca.ListCertificateAuthoritiesOutput
-	DescribeCertificateAuthorityOutput acmpca.DescribeCertificateAuthorityOutput
-	UpdateCertificateAuthorityOutput   acmpca.UpdateCertificateAuthorityOutput
-	DeleteCertificateAuthorityOutput   acmpca.DeleteCertificateAuthorityOutput
+	ACMPCAServiceAPI
+	acmpca.DeleteCertificateAuthorityOutput
+	acmpca.DescribeCertificateAuthorityOutput
+	acmpca.ListCertificateAuthoritiesOutput
+	acmpca.UpdateCertificateAuthorityOutput
 }
 
-func (m mockedACMPCA) ListCertificateAuthoritiesPagesWithContext(_ awsgo.Context, _ *acmpca.ListCertificateAuthoritiesInput, fn func(*acmpca.ListCertificateAuthoritiesOutput, bool) bool, _ ...request.Option) error {
-	// Only need to return mocked response output
-	fn(&m.ListCertificateAuthoritiesOutput, true)
-	return nil
+func (m mockedACMPCA) DeleteCertificateAuthority(ctx context.Context, params *acmpca.DeleteCertificateAuthorityInput, optFns ...func(*acmpca.Options)) (*acmpca.DeleteCertificateAuthorityOutput, error) {
+	return &m.DeleteCertificateAuthorityOutput, nil
 }
 
-func (m mockedACMPCA) DescribeCertificateAuthorityWithContext(_ awsgo.Context, _ *acmpca.DescribeCertificateAuthorityInput, _ ...request.Option) (*acmpca.DescribeCertificateAuthorityOutput, error) {
+func (m mockedACMPCA) DescribeCertificateAuthority(ctx context.Context, params *acmpca.DescribeCertificateAuthorityInput, optFns ...func(*acmpca.Options)) (*acmpca.DescribeCertificateAuthorityOutput, error) {
 	return &m.DescribeCertificateAuthorityOutput, nil
 }
 
-func (m mockedACMPCA) UpdateCertificateAuthorityWithContext(_ awsgo.Context, _ *acmpca.UpdateCertificateAuthorityInput, _ ...request.Option) (*acmpca.UpdateCertificateAuthorityOutput, error) {
-	return &m.UpdateCertificateAuthorityOutput, nil
+func (m mockedACMPCA) ListCertificateAuthorities(ctx context.Context, params *acmpca.ListCertificateAuthoritiesInput, optFns ...func(*acmpca.Options)) (*acmpca.ListCertificateAuthoritiesOutput, error) {
+	return &m.ListCertificateAuthoritiesOutput, nil
 }
 
-func (m mockedACMPCA) DeleteCertificateAuthorityWithContext(_ awsgo.Context, _ *acmpca.DeleteCertificateAuthorityInput, _ ...request.Option) (*acmpca.DeleteCertificateAuthorityOutput, error) {
-	return &m.DeleteCertificateAuthorityOutput, nil
+func (m mockedACMPCA) UpdateCertificateAuthority(ctx context.Context, params *acmpca.UpdateCertificateAuthorityInput, optFns ...func(*acmpca.Options)) (*acmpca.UpdateCertificateAuthorityOutput, error) {
+	return &m.UpdateCertificateAuthorityOutput, nil
 }
 
 func TestAcmPcaGetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testArn := "test-arn"
@@ -49,7 +44,7 @@ func TestAcmPcaGetAll(t *testing.T) {
 	acmPca := ACMPCA{
 		Client: mockedACMPCA{
 			ListCertificateAuthoritiesOutput: acmpca.ListCertificateAuthoritiesOutput{
-				CertificateAuthorities: []*acmpca.CertificateAuthority{
+				CertificateAuthorities: []types.CertificateAuthority{
 					{
 						CreatedAt: &now,
 						Arn:       &testArn,
@@ -62,20 +57,20 @@ func TestAcmPcaGetAll(t *testing.T) {
 	// without filters
 	arns, err := acmPca.getAll(context.Background(), config.Config{})
 	require.NoError(t, err)
-	require.Contains(t, awsgo.StringValueSlice(arns), testArn)
+	require.Contains(t, aws.ToStringSlice(arns), testArn)
 
 	// with exclude after filter
 	arns, err = acmPca.getAll(context.Background(), config.Config{
 		ACMPCA: config.ResourceType{
 			ExcludeRule: config.FilterRule{
-				TimeAfter: awsgo.Time(now.Add(-1))}},
+				TimeAfter: aws.Time(now.Add(-1))}},
 	})
+
 	require.NoError(t, err)
-	require.NotContains(t, awsgo.StringValueSlice(arns), testArn)
+	require.NotContains(t, aws.ToStringSlice(arns), testArn)
 }
 
 func TestAcmPcaNukeAll_DisabledCA(t *testing.T) {
-
 	t.Parallel()
 
 	testArn := "test-arn"
@@ -83,8 +78,8 @@ func TestAcmPcaNukeAll_DisabledCA(t *testing.T) {
 	acmPca := ACMPCA{
 		Client: mockedACMPCA{
 			DescribeCertificateAuthorityOutput: acmpca.DescribeCertificateAuthorityOutput{
-				CertificateAuthority: &acmpca.CertificateAuthority{
-					Status:    awsgo.String(acmpca.CertificateAuthorityStatusDisabled),
+				CertificateAuthority: &types.CertificateAuthority{
+					Status:    types.CertificateAuthorityStatusDisabled,
 					CreatedAt: &now,
 					Arn:       &testArn,
 				},
@@ -98,7 +93,6 @@ func TestAcmPcaNukeAll_DisabledCA(t *testing.T) {
 }
 
 func TestAcmPcaNukeAll_EnabledCA(t *testing.T) {
-
 	t.Parallel()
 
 	testArn := "test-arn"
@@ -106,8 +100,8 @@ func TestAcmPcaNukeAll_EnabledCA(t *testing.T) {
 	acmPca := ACMPCA{
 		Client: mockedACMPCA{
 			DescribeCertificateAuthorityOutput: acmpca.DescribeCertificateAuthorityOutput{
-				CertificateAuthority: &acmpca.CertificateAuthority{
-					Status:    awsgo.String(acmpca.CertificateAuthorityStatusActive),
+				CertificateAuthority: &types.CertificateAuthority{
+					Status:    types.CertificateAuthorityStatusActive,
 					CreatedAt: &now,
 					Arn:       &testArn,
 				},
diff --git a/aws/resources/ami_test.go b/aws/resources/ami_test.go
index ec05c4f..50f814f 100644
--- a/aws/resources/ami_test.go
+++ b/aws/resources/ami_test.go
@@ -7,31 +7,27 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"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/assert"
-
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 )
 
 type mockedAMI struct {
-	ec2iface.EC2API
-	DescribeImagesOutput  ec2.DescribeImagesOutput
+	AMIsAPI
 	DeregisterImageOutput ec2.DeregisterImageOutput
+	DescribeImagesOutput  ec2.DescribeImagesOutput
 }
 
-func (m mockedAMI) DescribeImagesWithContext(_ awsgo.Context, _ *ec2.DescribeImagesInput, _ ...request.Option) (*ec2.DescribeImagesOutput, error) {
-	return &m.DescribeImagesOutput, nil
+func (m mockedAMI) DeregisterImage(ctx context.Context, params *ec2.DeregisterImageInput, optFns ...func(*ec2.Options)) (*ec2.DeregisterImageOutput, error) {
+	return &m.DeregisterImageOutput, nil
 }
 
-func (m mockedAMI) DeregisterImageWithContext(_ awsgo.Context, _ *ec2.DeregisterImageInput, _ ...request.Option) (*ec2.DeregisterImageOutput, error) {
-	return &m.DeregisterImageOutput, nil
+func (m mockedAMI) DescribeImages(ctx context.Context, params *ec2.DescribeImagesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error) {
+	return &m.DescribeImagesOutput, nil
 }
 
 func TestAMIGetAll_SkipAWSManaged(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "test-ami"
@@ -41,12 +37,12 @@ func TestAMIGetAll_SkipAWSManaged(t *testing.T) {
 	acm := AMIs{
 		Client: mockedAMI{
 			DescribeImagesOutput: ec2.DescribeImagesOutput{
-				Images: []*ec2.Image{
+				Images: []types.Image{
 					{
 						ImageId:      &testImageId1,
 						Name:         &testName,
-						CreationDate: awsgo.String(now.Format("2006-01-02T15:04:05.000Z")),
-						Tags: []*ec2.Tag{
+						CreationDate: aws.String(now.Format("2006-01-02T15:04:05.000Z")),
+						Tags: []types.Tag{
 							{
 								Key:   aws.String("aws-managed"),
 								Value: aws.String("true"),
@@ -56,8 +52,8 @@ func TestAMIGetAll_SkipAWSManaged(t *testing.T) {
 					{
 						ImageId:      &testImageId2,
 						Name:         aws.String("AwsBackup_Test"),
-						CreationDate: awsgo.String(now.Format("2006-01-02T15:04:05.000Z")),
-						Tags: []*ec2.Tag{
+						CreationDate: aws.String(now.Format("2006-01-02T15:04:05.000Z")),
+						Tags: []types.Tag{
 							{
 								Key:   aws.String("aws-managed"),
 								Value: aws.String("true"),
@@ -71,12 +67,11 @@ func TestAMIGetAll_SkipAWSManaged(t *testing.T) {
 
 	amis, err := acm.getAll(context.Background(), config.Config{})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(amis), testImageId1)
-	assert.NotContains(t, awsgo.StringValueSlice(amis), testImageId2)
+	assert.NotContains(t, aws.ToStringSlice(amis), testImageId1)
+	assert.NotContains(t, aws.ToStringSlice(amis), testImageId2)
 }
 
 func TestAMIGetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "test-ami"
@@ -85,10 +80,10 @@ func TestAMIGetAll(t *testing.T) {
 	acm := AMIs{
 		Client: mockedAMI{
 			DescribeImagesOutput: ec2.DescribeImagesOutput{
-				Images: []*ec2.Image{{
+				Images: []types.Image{{
 					ImageId:      &testImageId,
 					Name:         &testName,
-					CreationDate: awsgo.String(now.Format("2006-01-02T15:04:05.000Z")),
+					CreationDate: aws.String(now.Format("2006-01-02T15:04:05.000Z")),
 				}},
 			},
 		},
@@ -97,7 +92,7 @@ func TestAMIGetAll(t *testing.T) {
 	// without filters
 	amis, err := acm.getAll(context.Background(), config.Config{})
 	assert.NoError(t, err)
-	assert.Contains(t, awsgo.StringValueSlice(amis), testImageId)
+	assert.Contains(t, aws.ToStringSlice(amis), testImageId)
 
 	// with name filter
 	amis, err = acm.getAll(context.Background(), config.Config{
@@ -107,19 +102,18 @@ func TestAMIGetAll(t *testing.T) {
 					RE: *regexp.MustCompile("test-ami"),
 				}}}}})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(amis), testImageId)
+	assert.NotContains(t, aws.ToStringSlice(amis), testImageId)
 
 	// with time filter
 	amis, err = acm.getAll(context.Background(), config.Config{
 		AMI: config.ResourceType{
 			ExcludeRule: config.FilterRule{
-				TimeAfter: awsgo.Time(now.Add(-12 * time.Hour))}}})
+				TimeAfter: aws.Time(now.Add(-12 * time.Hour))}}})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(amis), testImageId)
+	assert.NotContains(t, aws.ToStringSlice(amis), testImageId)
 }
 
 func TestAMINukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "test-ami"
diff --git a/aws/resources/apigateway_test.go b/aws/resources/apigateway_test.go
index 578e74b..793f16b 100644
--- a/aws/resources/apigateway_test.go
+++ b/aws/resources/apigateway_test.go
@@ -5,11 +5,9 @@ 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/apigateway"
-	"github.com/aws/aws-sdk-go/service/apigateway/apigatewayiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apigateway"
+	"github.com/aws/aws-sdk-go-v2/service/apigateway/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/gruntwork-io/cloud-nuke/util"
 	"github.com/stretchr/testify/assert"
@@ -17,64 +15,61 @@ import (
 )
 
 type mockedApiGateway struct {
-	apigatewayiface.APIGatewayAPI
-	GetRestApisResp               apigateway.GetRestApisOutput
-	DeleteRestApiResp             apigateway.DeleteRestApiOutput
+	ApiGatewayServiceAPI
+	GetRestApisOutput             apigateway.GetRestApisOutput
 	GetStagesOutput               apigateway.GetStagesOutput
 	DeleteClientCertificateOutput apigateway.DeleteClientCertificateOutput
+	DeleteRestApiOutput           apigateway.DeleteRestApiOutput
 }
 
-func (m mockedApiGateway) GetRestApisWithContext(_ awsgo.Context, _ *apigateway.GetRestApisInput, _ ...request.Option) (*apigateway.GetRestApisOutput, error) {
-	// Only need to return mocked response output
-	return &m.GetRestApisResp, nil
+func (m mockedApiGateway) GetRestApis(ctx context.Context, params *apigateway.GetRestApisInput, optFns ...func(*apigateway.Options)) (*apigateway.GetRestApisOutput, error) {
+	return &m.GetRestApisOutput, nil
 }
-
-func (m mockedApiGateway) DeleteRestApiWithContext(_ awsgo.Context, _ *apigateway.DeleteRestApiInput, _ ...request.Option) (*apigateway.DeleteRestApiOutput, error) {
-	// Only need to return mocked response output
-	return &m.DeleteRestApiResp, nil
-}
-func (m mockedApiGateway) GetStagesWithContext(_ awsgo.Context, _ *apigateway.GetStagesInput, _ ...request.Option) (*apigateway.GetStagesOutput, error) {
+func (m mockedApiGateway) GetStages(ctx context.Context, params *apigateway.GetStagesInput, optFns ...func(*apigateway.Options)) (*apigateway.GetStagesOutput, error) {
 	return &m.GetStagesOutput, nil
 }
 
-func (m mockedApiGateway) DeleteClientCertificateWithContext(_ awsgo.Context, _ *apigateway.DeleteClientCertificateInput, _ ...request.Option) (*apigateway.DeleteClientCertificateOutput, error) {
+func (m mockedApiGateway) DeleteClientCertificate(ctx context.Context, params *apigateway.DeleteClientCertificateInput, optFns ...func(*apigateway.Options)) (*apigateway.DeleteClientCertificateOutput, error) {
 	return &m.DeleteClientCertificateOutput, nil
 }
 
-func TestAPIGatewayGetAllAndNukeAll(t *testing.T) {
+func (m mockedApiGateway) DeleteRestApi(ctx context.Context, params *apigateway.DeleteRestApiInput, optFns ...func(*apigateway.Options)) (*apigateway.DeleteRestApiOutput, error) {
+	return &m.DeleteRestApiOutput, nil
+}
 
+func TestAPIGatewayGetAllAndNukeAll(t *testing.T) {
 	t.Parallel()
 
 	testApiID := "aws-nuke-test-" + util.UniqueID()
 	apiGateway := ApiGateway{
 		Client: mockedApiGateway{
-			GetRestApisResp: apigateway.GetRestApisOutput{
-				Items: []*apigateway.RestApi{
+			ApiGatewayServiceAPI: nil,
+			GetRestApisOutput: apigateway.GetRestApisOutput{
+				Items: []types.RestApi{
 					{Id: aws.String(testApiID)},
 				},
 			},
-			DeleteRestApiResp: apigateway.DeleteRestApiOutput{},
+			DeleteRestApiOutput: apigateway.DeleteRestApiOutput{},
 		},
 	}
 
 	apis, err := apiGateway.getAll(context.Background(), config.Config{})
 	require.NoError(t, err)
-	require.Contains(t, awsgo.StringValueSlice(apis), testApiID)
+	require.Contains(t, aws.ToStringSlice(apis), testApiID)
 
 	err = apiGateway.nukeAll([]*string{aws.String(testApiID)})
 	require.NoError(t, err)
 }
 
 func TestAPIGatewayGetAllTimeFilter(t *testing.T) {
-
 	t.Parallel()
 
 	testApiID := "aws-nuke-test-" + util.UniqueID()
 	now := time.Now()
 	apiGateway := ApiGateway{
 		Client: mockedApiGateway{
-			GetRestApisResp: apigateway.GetRestApisOutput{
-				Items: []*apigateway.RestApi{{
+			GetRestApisOutput: apigateway.GetRestApisOutput{
+				Items: []types.RestApi{{
 					Id:          aws.String(testApiID),
 					CreatedDate: aws.Time(now),
 				}},
@@ -91,7 +86,7 @@ func TestAPIGatewayGetAllTimeFilter(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	assert.Contains(t, aws.StringValueSlice(IDs), testApiID)
+	assert.Contains(t, aws.ToStringSlice(IDs), testApiID)
 
 	// test API being excluded from the filter
 	apiGwIdsOlder, err := apiGateway.getAll(context.Background(), config.Config{
@@ -102,38 +97,36 @@ func TestAPIGatewayGetAllTimeFilter(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	assert.NotContains(t, aws.StringValueSlice(apiGwIdsOlder), testApiID)
+	assert.NotContains(t, aws.ToStringSlice(apiGwIdsOlder), testApiID)
 }
 
 func TestNukeAPIGatewayMoreThanOne(t *testing.T) {
-
 	t.Parallel()
 
 	testApiID1 := "aws-nuke-test-" + util.UniqueID()
 	testApiID2 := "aws-nuke-test-" + util.UniqueID()
 	apiGateway := ApiGateway{
 		Client: mockedApiGateway{
-			GetRestApisResp: apigateway.GetRestApisOutput{
-				Items: []*apigateway.RestApi{
+			GetRestApisOutput: apigateway.GetRestApisOutput{
+				Items: []types.RestApi{
 					{Id: aws.String(testApiID1)},
 					{Id: aws.String(testApiID2)},
 				},
 			},
-			DeleteRestApiResp: apigateway.DeleteRestApiOutput{},
+			DeleteRestApiOutput: apigateway.DeleteRestApiOutput{},
 		},
 	}
 
 	apis, err := apiGateway.getAll(context.Background(), config.Config{})
 	require.NoError(t, err)
-	require.Contains(t, awsgo.StringValueSlice(apis), testApiID1)
-	require.Contains(t, awsgo.StringValueSlice(apis), testApiID2)
+	require.Contains(t, aws.ToStringSlice(apis), testApiID1)
+	require.Contains(t, aws.ToStringSlice(apis), testApiID2)
 
 	err = apiGateway.nukeAll([]*string{aws.String(testApiID1), aws.String(testApiID2)})
 	require.NoError(t, err)
 }
 
 func TestNukeAPIGatewayWithCertificates(t *testing.T) {
-
 	t.Parallel()
 
 	testApiID1 := "aws-nuke-test-" + util.UniqueID()
@@ -142,28 +135,28 @@ func TestNukeAPIGatewayWithCertificates(t *testing.T) {
 	clientCertID := "aws-client-cert" + util.UniqueID()
 	apiGateway := ApiGateway{
 		Client: mockedApiGateway{
-			GetRestApisResp: apigateway.GetRestApisOutput{
-				Items: []*apigateway.RestApi{
+			GetRestApisOutput: apigateway.GetRestApisOutput{
+				Items: []types.RestApi{
 					{Id: aws.String(testApiID1)},
 					{Id: aws.String(testApiID2)},
 				},
 			},
 			GetStagesOutput: apigateway.GetStagesOutput{
-				Item: []*apigateway.Stage{
+				Item: []types.Stage{
 					{
 						ClientCertificateId: aws.String(clientCertID),
 					},
 				},
 			},
 			DeleteClientCertificateOutput: apigateway.DeleteClientCertificateOutput{},
-			DeleteRestApiResp:             apigateway.DeleteRestApiOutput{},
+			DeleteRestApiOutput:           apigateway.DeleteRestApiOutput{},
 		},
 	}
 
 	apis, err := apiGateway.getAll(context.Background(), config.Config{})
 	require.NoError(t, err)
-	require.Contains(t, awsgo.StringValueSlice(apis), testApiID1)
-	require.Contains(t, awsgo.StringValueSlice(apis), testApiID2)
+	require.Contains(t, aws.ToStringSlice(apis), testApiID1)
+	require.Contains(t, aws.ToStringSlice(apis), testApiID2)
 
 	err = apiGateway.nukeAll([]*string{aws.String(testApiID1), aws.String(testApiID2)})
 	require.NoError(t, err)
diff --git a/aws/resources/apigatewayv2_test.go b/aws/resources/apigatewayv2_test.go
index 561e595..a0e3ae5 100644
--- a/aws/resources/apigatewayv2_test.go
+++ b/aws/resources/apigatewayv2_test.go
@@ -6,49 +6,43 @@ 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/aws"
-	"github.com/aws/aws-sdk-go/service/apigatewayv2"
-	"github.com/aws/aws-sdk-go/service/apigatewayv2/apigatewayv2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apigatewayv2"
+	"github.com/aws/aws-sdk-go-v2/service/apigatewayv2/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/assert"
 )
 
 type mockedApiGatewayV2 struct {
-	apigatewayv2iface.ApiGatewayV2API
+	ApiGatewayV2API
 	GetApisOutput          apigatewayv2.GetApisOutput
-	DeleteApiOutput        apigatewayv2.DeleteApiOutput
 	GetDomainNamesOutput   apigatewayv2.GetDomainNamesOutput
 	GetApiMappingsOutput   apigatewayv2.GetApiMappingsOutput
+	DeleteApiOutput        apigatewayv2.DeleteApiOutput
 	DeleteApiMappingOutput apigatewayv2.DeleteApiMappingOutput
 }
 
-func (m mockedApiGatewayV2) GetApisWithContext(_ awsgo.Context, _ *apigatewayv2.GetApisInput, _ ...request.Option) (*apigatewayv2.GetApisOutput, error) {
-	// Only need to return mocked response output
-	return &m.GetApisOutput, nil
+func (m mockedApiGatewayV2) DeleteApi(ctx context.Context, params *apigatewayv2.DeleteApiInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.DeleteApiOutput, error) {
+	return &m.DeleteApiOutput, nil
 }
 
-func (m mockedApiGatewayV2) DeleteApiWithContext(_ awsgo.Context, _ *apigatewayv2.DeleteApiInput, _ ...request.Option) (*apigatewayv2.DeleteApiOutput, error) {
-	// Only need to return mocked response output
-	return &m.DeleteApiOutput, nil
+func (m mockedApiGatewayV2) DeleteApiMapping(ctx context.Context, params *apigatewayv2.DeleteApiMappingInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.DeleteApiMappingOutput, error) {
+	return &m.DeleteApiMappingOutput, nil
 }
 
-func (m mockedApiGatewayV2) GetDomainNames(_ *apigatewayv2.GetDomainNamesInput) (*apigatewayv2.GetDomainNamesOutput, error) {
-	return &m.GetDomainNamesOutput, nil
+func (m mockedApiGatewayV2) GetApis(ctx context.Context, params *apigatewayv2.GetApisInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.GetApisOutput, error) {
+	return &m.GetApisOutput, nil
 }
 
-func (m mockedApiGatewayV2) GetApiMappings(_ *apigatewayv2.GetApiMappingsInput) (*apigatewayv2.GetApiMappingsOutput, error) {
+func (m mockedApiGatewayV2) GetApiMappings(ctx context.Context, params *apigatewayv2.GetApiMappingsInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.GetApiMappingsOutput, error) {
 	return &m.GetApiMappingsOutput, nil
 }
 
-func (m mockedApiGatewayV2) DeleteApiMappingWithContext(_ awsgo.Context, _ *apigatewayv2.DeleteApiMappingInput, _ ...request.Option) (*apigatewayv2.DeleteApiMappingOutput, error) {
-	return &m.DeleteApiMappingOutput, nil
+func (m mockedApiGatewayV2) GetDomainNames(ctx context.Context, params *apigatewayv2.GetDomainNamesInput, optFns ...func(*apigatewayv2.Options)) (*apigatewayv2.GetDomainNamesOutput, error) {
+	return &m.GetDomainNamesOutput, nil
 }
 
 func TestApiGatewayV2GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testApiID := "test-api-id"
@@ -57,7 +51,7 @@ func TestApiGatewayV2GetAll(t *testing.T) {
 	gw := ApiGatewayV2{
 		Client: mockedApiGatewayV2{
 			GetApisOutput: apigatewayv2.GetApisOutput{
-				Items: []*apigatewayv2.Api{
+				Items: []types.Api{
 					{
 						ApiId:       aws.String(testApiID),
 						Name:        aws.String(testApiName),
@@ -71,7 +65,7 @@ func TestApiGatewayV2GetAll(t *testing.T) {
 	// empty filter
 	apis, err := gw.getAll(context.Background(), config.Config{})
 	assert.NoError(t, err)
-	assert.Contains(t, awsgo.StringValueSlice(apis), testApiID)
+	assert.Contains(t, aws.ToStringSlice(apis), testApiID)
 
 	// filter by name
 	apis, err = gw.getAll(context.Background(), config.Config{
@@ -81,33 +75,32 @@ func TestApiGatewayV2GetAll(t *testing.T) {
 					RE: *regexp.MustCompile("test-api-name"),
 				}}}}})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(apis), testApiID)
+	assert.NotContains(t, aws.ToStringSlice(apis), testApiID)
 
 	// filter by date
 	apis, err = gw.getAll(context.Background(), config.Config{
 		APIGatewayV2: config.ResourceType{
 			ExcludeRule: config.FilterRule{
-				TimeAfter: awsgo.Time(now.Add(-1))}}})
+				TimeAfter: aws.Time(now.Add(-1))}}})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(apis), testApiID)
+	assert.NotContains(t, aws.ToStringSlice(apis), testApiID)
 }
 
 func TestApiGatewayV2NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	gw := ApiGatewayV2{
 		Client: mockedApiGatewayV2{
 			DeleteApiOutput: apigatewayv2.DeleteApiOutput{},
 			GetDomainNamesOutput: apigatewayv2.GetDomainNamesOutput{
-				Items: []*apigatewayv2.DomainName{
+				Items: []types.DomainName{
 					{
 						DomainName: aws.String("test-domain-name"),
 					},
 				},
 			},
 			GetApisOutput: apigatewayv2.GetApisOutput{
-				Items: []*apigatewayv2.Api{
+				Items: []types.Api{
 					{
 						ApiId: aws.String("test-api-id"),
 					},
diff --git a/aws/resources/apprunner_service_test.go b/aws/resources/apprunner_service_test.go
index 4b75d47..360eafd 100644
--- a/aws/resources/apprunner_service_test.go
+++ b/aws/resources/apprunner_service_test.go
@@ -7,32 +7,29 @@ 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/apprunner"
-	"github.com/aws/aws-sdk-go/service/apprunner/apprunneriface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/apprunner"
+	"github.com/aws/aws-sdk-go-v2/service/apprunner/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedAppRunnerService struct {
-	apprunneriface.AppRunnerAPI
-	ListServicesOutput  apprunner.ListServicesOutput
+	AppRunnerServiceAPI
 	DeleteServiceOutput apprunner.DeleteServiceOutput
+	ListServicesOutput  apprunner.ListServicesOutput
 }
 
-func (m mockedAppRunnerService) ListServicesPagesWithContext(_ aws.Context, _ *apprunner.ListServicesInput, callback func(*apprunner.ListServicesOutput, bool) bool, _ ...request.Option) error {
-	callback(&m.ListServicesOutput, true)
-	return nil
+func (m mockedAppRunnerService) DeleteService(ctx context.Context, params *apprunner.DeleteServiceInput, optFns ...func(*apprunner.Options)) (*apprunner.DeleteServiceOutput, error) {
+	return &m.DeleteServiceOutput, nil
 }
 
-func (m mockedAppRunnerService) DeleteServiceWithContext(aws.Context, *apprunner.DeleteServiceInput, ...request.Option) (*apprunner.DeleteServiceOutput, error) {
-	return &m.DeleteServiceOutput, nil
+func (m mockedAppRunnerService) ListServices(ctx context.Context, params *apprunner.ListServicesInput, optFns ...func(*apprunner.Options)) (*apprunner.ListServicesOutput, error) {
+	return &m.ListServicesOutput, nil
 }
 
 func Test_AppRunnerService_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-service-1"
@@ -41,7 +38,7 @@ func Test_AppRunnerService_GetAll(t *testing.T) {
 	service := AppRunnerService{
 		Client: mockedAppRunnerService{
 			ListServicesOutput: apprunner.ListServicesOutput{
-				ServiceSummaryList: []*apprunner.ServiceSummary{
+				ServiceSummaryList: []types.ServiceSummary{
 					{
 						ServiceName: &testName1,
 						ServiceArn:  aws.String(fmt.Sprintf("arn::%s", testName1)),
@@ -88,13 +85,12 @@ func Test_AppRunnerService_GetAll(t *testing.T) {
 				AppRunnerService: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestAppRunnerService_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "test-app-runner-service"
diff --git a/aws/resources/asg_test.go b/aws/resources/asg_test.go
index eb177dc..4a91f17 100644
--- a/aws/resources/asg_test.go
+++ b/aws/resources/asg_test.go
@@ -6,51 +6,44 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface"
-
-	awsgo "github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/assert"
 )
 
 type mockedASGroups struct {
-	autoscalingiface.AutoScalingAPI
-	DescribeAutoScalingGroupsResp autoscaling.DescribeAutoScalingGroupsOutput
-	DeleteAutoScalingGroupResp    autoscaling.DeleteAutoScalingGroupOutput
-}
-
-func (m mockedASGroups) DescribeAutoScalingGroupsWithContext(_ awsgo.Context, _ *autoscaling.DescribeAutoScalingGroupsInput, _ ...request.Option) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
-	return &m.DescribeAutoScalingGroupsResp, nil
+	ASGroupsAPI
+	DescribeAutoScalingGroupsOutput autoscaling.DescribeAutoScalingGroupsOutput
+	DeleteAutoScalingGroupOutput    autoscaling.DeleteAutoScalingGroupOutput
 }
 
-func (m mockedASGroups) DeleteAutoScalingGroupWithContext(_ awsgo.Context, _ *autoscaling.DeleteAutoScalingGroupInput, _ ...request.Option) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
-	return &m.DeleteAutoScalingGroupResp, nil
+func (m mockedASGroups) DescribeAutoScalingGroups(ctx context.Context, params *autoscaling.DescribeAutoScalingGroupsInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
+	return &m.DescribeAutoScalingGroupsOutput, nil
 }
 
-func (m mockedASGroups) WaitUntilGroupNotExistsWithContext(_ awsgo.Context, _ *autoscaling.DescribeAutoScalingGroupsInput, _ ...request.WaiterOption) error {
-	return nil
+func (m mockedASGroups) DeleteAutoScalingGroup(ctx context.Context, params *autoscaling.DeleteAutoScalingGroupInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
+	return &m.DeleteAutoScalingGroupOutput, nil
 }
 
 func TestAutoScalingGroupGetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "cloud-nuke-test"
 	now := time.Now()
 	ag := ASGroups{
 		Client: mockedASGroups{
-			DescribeAutoScalingGroupsResp: autoscaling.DescribeAutoScalingGroupsOutput{
-				AutoScalingGroups: []*autoscaling.Group{{
-					AutoScalingGroupName: awsgo.String(testName),
-					CreatedTime:          awsgo.Time(now),
+			DescribeAutoScalingGroupsOutput: autoscaling.DescribeAutoScalingGroupsOutput{
+				AutoScalingGroups: []types.AutoScalingGroup{{
+					AutoScalingGroupName: aws.String(testName),
+					CreatedTime:          aws.Time(now),
 				}}}}}
 
 	// empty filter
 	groups, err := ag.getAll(context.Background(), config.Config{})
 	assert.NoError(t, err)
-	assert.Contains(t, awsgo.StringValueSlice(groups), testName)
+	assert.Contains(t, aws.ToStringSlice(groups), testName)
 
 	// name filter
 	groups, err = ag.getAll(context.Background(), config.Config{
@@ -60,27 +53,30 @@ func TestAutoScalingGroupGetAll(t *testing.T) {
 					RE: *regexp.MustCompile("^cloud-nuke-*"),
 				}}}}})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(groups), testName)
+	assert.NotContains(t, aws.ToStringSlice(groups), testName)
 
 	// time filter
 	groups, err = ag.getAll(context.Background(), config.Config{
 		AutoScalingGroup: config.ResourceType{
 			ExcludeRule: config.FilterRule{
-				TimeAfter: awsgo.Time(now.Add(-1)),
+				TimeAfter: aws.Time(now.Add(-1)),
 			}}})
 	assert.NoError(t, err)
-	assert.NotContains(t, awsgo.StringValueSlice(groups), testName)
+	assert.NotContains(t, aws.ToStringSlice(groups), testName)
 }
 
 func TestAutoScalingGroupNukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	ag := ASGroups{
+		BaseAwsResource: BaseAwsResource{
+			Context: context.Background(),
+		},
 		Client: mockedASGroups{
-			DeleteAutoScalingGroupResp: autoscaling.DeleteAutoScalingGroupOutput{},
-		}}
+			DeleteAutoScalingGroupOutput: autoscaling.DeleteAutoScalingGroupOutput{},
+		},
+	}
 
-	err := ag.nukeAll([]*string{awsgo.String("cloud-nuke-test")})
+	err := ag.nukeAll([]*string{aws.String("cloud-nuke-test")})
 	assert.NoError(t, err)
 }
diff --git a/aws/resources/backup_vault_test.go b/aws/resources/backup_vault_test.go
index 26883ec..1121ae2 100644
--- a/aws/resources/backup_vault_test.go
+++ b/aws/resources/backup_vault_test.go
@@ -6,47 +6,38 @@ 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/backup/backupiface"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/backup"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/backup"
+	"github.com/aws/aws-sdk-go-v2/service/backup/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedBackupVault struct {
-	backupiface.BackupAPI
+	BackupVaultAPI
+	DeleteBackupVaultOutput               backup.DeleteBackupVaultOutput
+	DeleteRecoveryPointOutput             backup.DeleteRecoveryPointOutput
 	ListBackupVaultsOutput                backup.ListBackupVaultsOutput
 	ListRecoveryPointsByBackupVaultOutput backup.ListRecoveryPointsByBackupVaultOutput
-	DeleteRecoveryPointOutput             backup.DeleteRecoveryPointOutput
-	DeleteBackupVaultOutput               backup.DeleteBackupVaultOutput
-}
-
-func (m mockedBackupVault) ListBackupVaultsPagesWithContext(_ awsgo.Context, _ *backup.ListBackupVaultsInput, fn func(*backup.ListBackupVaultsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListBackupVaultsOutput, true)
-	return nil
 }
 
-func (m mockedBackupVault) DeleteBackupVaultWithContext(_ awsgo.Context, _ *backup.DeleteBackupVaultInput, _ ...request.Option) (*backup.DeleteBackupVaultOutput, error) {
+func (m mockedBackupVault) DeleteBackupVault(ctx context.Context, params *backup.DeleteBackupVaultInput, optFns ...func(*backup.Options)) (*backup.DeleteBackupVaultOutput, error) {
 	return &m.DeleteBackupVaultOutput, nil
 }
 
-func (m mockedBackupVault) ListRecoveryPointsByBackupVaultWithContext(aws.Context, *backup.ListRecoveryPointsByBackupVaultInput, ...request.Option) (*backup.ListRecoveryPointsByBackupVaultOutput, error) {
-	return &m.ListRecoveryPointsByBackupVaultOutput, nil
+func (m mockedBackupVault) DeleteRecoveryPoint(ctx context.Context, params *backup.DeleteRecoveryPointInput, optFns ...func(*backup.Options)) (*backup.DeleteRecoveryPointOutput, error) {
+	return &m.DeleteRecoveryPointOutput, nil
 }
 
-func (m mockedBackupVault) WaitUntilRecoveryPointsDeleted(*string) error {
-	return nil
+func (m mockedBackupVault) ListBackupVaults(ctx context.Context, params *backup.ListBackupVaultsInput, optFns ...func(*backup.Options)) (*backup.ListBackupVaultsOutput, error) {
+	return &m.ListBackupVaultsOutput, nil
 }
 
-func (m mockedBackupVault) DeleteRecoveryPointWithContext(aws.Context, *backup.DeleteRecoveryPointInput, ...request.Option) (*backup.DeleteRecoveryPointOutput, error) {
-	return &m.DeleteRecoveryPointOutput, nil
+func (m mockedBackupVault) ListRecoveryPointsByBackupVault(ctx context.Context, params *backup.ListRecoveryPointsByBackupVaultInput, optFns ...func(*backup.Options)) (*backup.ListRecoveryPointsByBackupVaultOutput, error) {
+	return &m.ListRecoveryPointsByBackupVaultOutput, nil
 }
 
 func TestBackupVaultGetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-backup-vault-1"
@@ -56,7 +47,7 @@ func TestBackupVaultGetAll(t *testing.T) {
 
 		Client: mockedBackupVault{
 			ListBackupVaultsOutput: backup.ListBackupVaultsOutput{
-				BackupVaultList: []*backup.VaultListMember{
+				BackupVaultList: []types.BackupVaultListMember{
 					{
 						BackupVaultName: aws.String(testName1),
 						CreationDate:    aws.Time(now),
@@ -102,13 +93,12 @@ func TestBackupVaultGetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, aws.StringValueSlice(names), tc.expected)
+			require.Equal(t, aws.ToStringSlice(names), tc.expected)
 		})
 	}
 }
 
 func TestBackupVaultNuke(t *testing.T) {
-
 	t.Parallel()
 
 	bv := BackupVault{
diff --git a/aws/resources/cloudtrail_test.go b/aws/resources/cloudtrail_test.go
index 6a05a8e..5d4226e 100644
--- a/aws/resources/cloudtrail_test.go
+++ b/aws/resources/cloudtrail_test.go
@@ -5,32 +5,28 @@ import (
 	"regexp"
 	"testing"
 
-	"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/cloudtrail"
-	"github.com/aws/aws-sdk-go/service/cloudtrail/cloudtrailiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudtrail"
+	"github.com/aws/aws-sdk-go-v2/service/cloudtrail/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedCloudTrail struct {
-	cloudtrailiface.CloudTrailAPI
+	CloudtrailTrailAPI
 	ListTrailsOutput  cloudtrail.ListTrailsOutput
 	DeleteTrailOutput cloudtrail.DeleteTrailOutput
 }
 
-func (m mockedCloudTrail) ListTrailsPagesWithContext(_ awsgo.Context, _ *cloudtrail.ListTrailsInput, fn func(*cloudtrail.ListTrailsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListTrailsOutput, true)
-	return nil
+func (m mockedCloudTrail) ListTrails(ctx context.Context, params *cloudtrail.ListTrailsInput, optFns ...func(*cloudtrail.Options)) (*cloudtrail.ListTrailsOutput, error) {
+	return &m.ListTrailsOutput, nil
 }
 
-func (m mockedCloudTrail) DeleteTrailWithContext(_ aws.Context, _ *cloudtrail.DeleteTrailInput, _ ...request.Option) (*cloudtrail.DeleteTrailOutput, error) {
+func (m mockedCloudTrail) DeleteTrail(ctx context.Context, params *cloudtrail.DeleteTrailInput, optFns ...func(*cloudtrail.Options)) (*cloudtrail.DeleteTrailOutput, error) {
 	return &m.DeleteTrailOutput, nil
 }
 
 func TestCloudTrailGetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-name1"
@@ -40,7 +36,7 @@ func TestCloudTrailGetAll(t *testing.T) {
 	ct := CloudtrailTrail{
 		Client: mockedCloudTrail{
 			ListTrailsOutput: cloudtrail.ListTrailsOutput{
-				Trails: []*cloudtrail.TrailInfo{
+				Trails: []types.TrailInfo{
 					{
 						Name:     aws.String(testName1),
 						TrailARN: aws.String(testArn1),
@@ -77,13 +73,12 @@ func TestCloudTrailGetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestCloudTrailNukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	ct := CloudtrailTrail{
diff --git a/aws/resources/cloudwatch_alarm_test.go b/aws/resources/cloudwatch_alarm_test.go
index 6afce6a..5756cf3 100644
--- a/aws/resources/cloudwatch_alarm_test.go
+++ b/aws/resources/cloudwatch_alarm_test.go
@@ -6,40 +6,32 @@ 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/cloudwatch/cloudwatchiface"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedCloudWatchAlarms struct {
-	cloudwatchiface.CloudWatchAPI
+	CloudWatchAlarmsAPI
 	DescribeAlarmsOutput    cloudwatch.DescribeAlarmsOutput
 	DeleteAlarmsOutput      cloudwatch.DeleteAlarmsOutput
 	PutCompositeAlarmOutput cloudwatch.PutCompositeAlarmOutput
 }
 
-func (m mockedCloudWatchAlarms) DescribeAlarmsPagesWithContext(_ awsgo.Context, _ *cloudwatch.DescribeAlarmsInput, fn func(*cloudwatch.DescribeAlarmsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.DescribeAlarmsOutput, true)
-	return nil
-}
-
-func (m mockedCloudWatchAlarms) PutCompositeAlarmWithContext(_ awsgo.Context, _ *cloudwatch.PutCompositeAlarmInput, _ ...request.Option) (*cloudwatch.PutCompositeAlarmOutput, error) {
-	return &m.PutCompositeAlarmOutput, nil
-}
-
-func (m mockedCloudWatchAlarms) DescribeAlarmsWithContext(_ awsgo.Context, _ *cloudwatch.DescribeAlarmsInput, _ ...request.Option) (*cloudwatch.DescribeAlarmsOutput, error) {
+func (m mockedCloudWatchAlarms) DescribeAlarms(ctx context.Context, params *cloudwatch.DescribeAlarmsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.DescribeAlarmsOutput, error) {
 	return &m.DescribeAlarmsOutput, nil
 }
 
-func (m mockedCloudWatchAlarms) DeleteAlarmsWithContext(_ awsgo.Context, _ *cloudwatch.DeleteAlarmsInput, _ ...request.Option) (*cloudwatch.DeleteAlarmsOutput, error) {
+func (m mockedCloudWatchAlarms) DeleteAlarms(ctx context.Context, params *cloudwatch.DeleteAlarmsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.DeleteAlarmsOutput, error) {
 	return &m.DeleteAlarmsOutput, nil
 }
 
+func (m mockedCloudWatchAlarms) PutCompositeAlarm(ctx context.Context, params *cloudwatch.PutCompositeAlarmInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.PutCompositeAlarmOutput, error) {
+	return &m.PutCompositeAlarmOutput, nil
+}
+
 func TestCloudWatchAlarm_GetAll(t *testing.T) {
 
 	t.Parallel()
@@ -50,7 +42,7 @@ func TestCloudWatchAlarm_GetAll(t *testing.T) {
 	cw := CloudWatchAlarms{
 		Client: mockedCloudWatchAlarms{
 			DescribeAlarmsOutput: cloudwatch.DescribeAlarmsOutput{
-				MetricAlarms: []*cloudwatch.MetricAlarm{
+				MetricAlarms: []types.MetricAlarm{
 					{AlarmName: aws.String(testName1), AlarmConfigurationUpdatedTimestamp: &now},
 					{AlarmName: aws.String(testName2), AlarmConfigurationUpdatedTimestamp: aws.Time(now.Add(1))},
 				}},
@@ -89,13 +81,12 @@ func TestCloudWatchAlarm_GetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestCloudWatchAlarms_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-name1"
@@ -104,7 +95,7 @@ func TestCloudWatchAlarms_NukeAll(t *testing.T) {
 	cw := CloudWatchAlarms{
 		Client: mockedCloudWatchAlarms{
 			DescribeAlarmsOutput: cloudwatch.DescribeAlarmsOutput{
-				MetricAlarms: []*cloudwatch.MetricAlarm{
+				MetricAlarms: []types.MetricAlarm{
 					{AlarmName: aws.String(testName1), AlarmConfigurationUpdatedTimestamp: &now},
 					{AlarmName: aws.String(testName2), AlarmConfigurationUpdatedTimestamp: aws.Time(now.Add(1))},
 				}},
@@ -117,7 +108,6 @@ func TestCloudWatchAlarms_NukeAll(t *testing.T) {
 }
 
 func TestCloudWatchCompositeAlarms_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testCompositeAlaram1 := "test-name1"
@@ -127,7 +117,7 @@ func TestCloudWatchCompositeAlarms_NukeAll(t *testing.T) {
 	cw := CloudWatchAlarms{
 		Client: mockedCloudWatchAlarms{
 			DescribeAlarmsOutput: cloudwatch.DescribeAlarmsOutput{
-				MetricAlarms: []*cloudwatch.MetricAlarm{
+				MetricAlarms: []types.MetricAlarm{
 					{AlarmName: aws.String(testCompositeAlaram1), AlarmConfigurationUpdatedTimestamp: &now},
 					{AlarmName: aws.String(testCompositeAlaram2), AlarmConfigurationUpdatedTimestamp: &now},
 				}},
diff --git a/aws/resources/cloudwatch_dashboard_test.go b/aws/resources/cloudwatch_dashboard_test.go
index fa030e0..f53ec20 100644
--- a/aws/resources/cloudwatch_dashboard_test.go
+++ b/aws/resources/cloudwatch_dashboard_test.go
@@ -6,33 +6,28 @@ 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/cloudwatch/cloudwatchiface"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedCloudWatchDashboard struct {
-	cloudwatchiface.CloudWatchAPI
+	CloudWatchDashboardsAPI
 	ListDashboardsOutput   cloudwatch.ListDashboardsOutput
 	DeleteDashboardsOutput cloudwatch.DeleteDashboardsOutput
 }
 
-func (m mockedCloudWatchDashboard) ListDashboardsPagesWithContext(_ awsgo.Context, _ *cloudwatch.ListDashboardsInput, fn func(*cloudwatch.ListDashboardsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListDashboardsOutput, true)
-	return nil
+func (m mockedCloudWatchDashboard) ListDashboards(ctx context.Context, params *cloudwatch.ListDashboardsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.ListDashboardsOutput, error) {
+	return &m.ListDashboardsOutput, nil
 }
 
-func (m mockedCloudWatchDashboard) DeleteDashboardsWithContext(_ awsgo.Context, _ *cloudwatch.DeleteDashboardsInput, _ ...request.Option) (*cloudwatch.DeleteDashboardsOutput, error) {
+func (m mockedCloudWatchDashboard) DeleteDashboards(ctx context.Context, params *cloudwatch.DeleteDashboardsInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.DeleteDashboardsOutput, error) {
 	return &m.DeleteDashboardsOutput, nil
 }
 
 func TestCloudWatchDashboard_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-name1"
@@ -41,7 +36,7 @@ func TestCloudWatchDashboard_GetAll(t *testing.T) {
 	cw := CloudWatchDashboards{
 		Client: mockedCloudWatchDashboard{
 			ListDashboardsOutput: cloudwatch.ListDashboardsOutput{
-				DashboardEntries: []*cloudwatch.DashboardEntry{
+				DashboardEntries: []types.DashboardEntry{
 					{
 						DashboardName: aws.String(testName1),
 						LastModified:  &now,
@@ -86,13 +81,12 @@ func TestCloudWatchDashboard_GetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestCloudWatchDashboard_NukeAll(t *testing.T) {
-
 	t.Parallel()
 	cw := CloudWatchDashboards{
 		Client: mockedCloudWatchDashboard{
diff --git a/aws/resources/cloudwatch_loggroup_test.go b/aws/resources/cloudwatch_loggroup_test.go
index 1181314..91bd2cf 100644
--- a/aws/resources/cloudwatch_loggroup_test.go
+++ b/aws/resources/cloudwatch_loggroup_test.go
@@ -6,32 +6,28 @@ 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/cloudwatchlogs"
-	"github.com/aws/aws-sdk-go/service/cloudwatchlogs/cloudwatchlogsiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedCloudWatchLogGroup struct {
-	cloudwatchlogsiface.CloudWatchLogsAPI
-	DeleteLogGroupOutput    cloudwatchlogs.DeleteLogGroupOutput
+	CloudWatchLogGroupsAPI
 	DescribeLogGroupsOutput cloudwatchlogs.DescribeLogGroupsOutput
+	DeleteLogGroupOutput    cloudwatchlogs.DeleteLogGroupOutput
 }
 
-func (m mockedCloudWatchLogGroup) DescribeLogGroupsPagesWithContext(_ awsgo.Context, _ *cloudwatchlogs.DescribeLogGroupsInput, fn func(*cloudwatchlogs.DescribeLogGroupsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.DescribeLogGroupsOutput, true)
-	return nil
+func (m mockedCloudWatchLogGroup) DescribeLogGroups(ctx context.Context, params *cloudwatchlogs.DescribeLogGroupsInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DescribeLogGroupsOutput, error) {
+	return &m.DescribeLogGroupsOutput, nil
 }
 
-func (m mockedCloudWatchLogGroup) DeleteLogGroupWithContext(_ awsgo.Context, _ *cloudwatchlogs.DeleteLogGroupInput, _ ...request.Option) (*cloudwatchlogs.DeleteLogGroupOutput, error) {
+func (m mockedCloudWatchLogGroup) DeleteLogGroup(ctx context.Context, params *cloudwatchlogs.DeleteLogGroupInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteLogGroupOutput, error) {
 	return &m.DeleteLogGroupOutput, nil
 }
 
 func TestCloudWatchLogGroup_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-name1"
@@ -40,7 +36,7 @@ func TestCloudWatchLogGroup_GetAll(t *testing.T) {
 	cw := CloudWatchLogGroups{
 		Client: mockedCloudWatchLogGroup{
 			DescribeLogGroupsOutput: cloudwatchlogs.DescribeLogGroupsOutput{
-				LogGroups: []*cloudwatchlogs.LogGroup{
+				LogGroups: []types.LogGroup{
 					{
 						LogGroupName: aws.String(testName1),
 						CreationTime: aws.Int64(now.UnixMilli()),
@@ -86,13 +82,12 @@ func TestCloudWatchLogGroup_GetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestCloudWatchLogGroup_NukeAll(t *testing.T) {
-
 	t.Parallel()
 	cw := CloudWatchLogGroups{
 		Client: mockedCloudWatchLogGroup{
diff --git a/aws/resources/codedeploy_application_test.go b/aws/resources/codedeploy_application_test.go
index cedd03b..ad4c421 100644
--- a/aws/resources/codedeploy_application_test.go
+++ b/aws/resources/codedeploy_application_test.go
@@ -6,36 +6,32 @@ 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/codedeploy/codedeployiface"
-	"github.com/stretchr/testify/require"
-
-	"github.com/aws/aws-sdk-go/service/codedeploy"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/codedeploy"
+	"github.com/aws/aws-sdk-go-v2/service/codedeploy/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
+	"github.com/stretchr/testify/require"
 )
 
 type mockedCodeDeployApplications struct {
-	codedeployiface.CodeDeployAPI
+	CodeDeployApplicationsAPI
 	ListApplicationsOutput     codedeploy.ListApplicationsOutput
 	BatchGetApplicationsOutput codedeploy.BatchGetApplicationsOutput
 	DeleteApplicationOutput    codedeploy.DeleteApplicationOutput
 }
 
-func (m mockedCodeDeployApplications) ListApplicationsPagesWithContext(_ awsgo.Context, _ *codedeploy.ListApplicationsInput, fn func(*codedeploy.ListApplicationsOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListApplicationsOutput, true)
-	return nil
+func (m mockedCodeDeployApplications) ListApplications(ctx context.Context, params *codedeploy.ListApplicationsInput, optFns ...func(*codedeploy.Options)) (*codedeploy.ListApplicationsOutput, error) {
+	return &m.ListApplicationsOutput, nil
 }
 
-func (m mockedCodeDeployApplications) BatchGetApplicationsWithContext(_ awsgo.Context, input *codedeploy.BatchGetApplicationsInput, _ ...request.Option) (*codedeploy.BatchGetApplicationsOutput, error) {
+func (m mockedCodeDeployApplications) BatchGetApplications(ctx context.Context, input *codedeploy.BatchGetApplicationsInput, optFns ...func(*codedeploy.Options)) (*codedeploy.BatchGetApplicationsOutput, error) {
 	// Filter out applications that don't match the input names
 	names := make(map[string]bool)
 	for _, name := range input.ApplicationNames {
-		names[*name] = true
+		names[name] = true
 	}
 
-	var matched []*codedeploy.ApplicationInfo
+	var matched []types.ApplicationInfo
 	for _, info := range m.BatchGetApplicationsOutput.ApplicationsInfo {
 		if names[*info.ApplicationName] {
 			matched = append(matched, info)
@@ -47,12 +43,11 @@ func (m mockedCodeDeployApplications) BatchGetApplicationsWithContext(_ awsgo.Co
 	}, nil
 }
 
-func (m mockedCodeDeployApplications) DeleteApplicationWithContext(_ awsgo.Context, _ *codedeploy.DeleteApplicationInput, _ ...request.Option) (*codedeploy.DeleteApplicationOutput, error) {
+func (m mockedCodeDeployApplications) DeleteApplication(ctx context.Context, params *codedeploy.DeleteApplicationInput, optFns ...func(*codedeploy.Options)) (*codedeploy.DeleteApplicationOutput, error) {
 	return &m.DeleteApplicationOutput, nil
 }
 
 func TestCodeDeployApplication_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "cloud-nuke-test-1"
@@ -61,13 +56,13 @@ func TestCodeDeployApplication_GetAll(t *testing.T) {
 	c := CodeDeployApplications{
 		Client: mockedCodeDeployApplications{
 			ListApplicationsOutput: codedeploy.ListApplicationsOutput{
-				Applications: []*string{
-					aws.String(testName1),
-					aws.String(testName2),
+				Applications: []string{
+					testName1,
+					testName2,
 				},
 			},
 			BatchGetApplicationsOutput: codedeploy.BatchGetApplicationsOutput{
-				ApplicationsInfo: []*codedeploy.ApplicationInfo{
+				ApplicationsInfo: []types.ApplicationInfo{
 					{
 						ApplicationName: aws.String(testName1),
 						CreateTime:      aws.Time(now),
@@ -113,7 +108,7 @@ func TestCodeDeployApplication_GetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
diff --git a/aws/resources/config_recorder_test.go b/aws/resources/config_recorder_test.go
index 26a1cda..c5e250a 100644
--- a/aws/resources/config_recorder_test.go
+++ b/aws/resources/config_recorder_test.go
@@ -5,31 +5,28 @@ import (
 	"regexp"
 	"testing"
 
-	"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/configservice"
-	"github.com/aws/aws-sdk-go/service/configservice/configserviceiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/configservice"
+	"github.com/aws/aws-sdk-go-v2/service/configservice/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedConfigServiceRecorders struct {
-	configserviceiface.ConfigServiceAPI
+	ConfigServiceRecordersAPI
 	DescribeConfigurationRecordersOutput configservice.DescribeConfigurationRecordersOutput
 	DeleteConfigurationRecorderOutput    configservice.DeleteConfigurationRecorderOutput
 }
 
-func (m mockedConfigServiceRecorders) DescribeConfigurationRecordersWithContext(_ awsgo.Context, _ *configservice.DescribeConfigurationRecordersInput, _ ...request.Option) (*configservice.DescribeConfigurationRecordersOutput, error) {
+func (m mockedConfigServiceRecorders) DescribeConfigurationRecorders(ctx context.Context, params *configservice.DescribeConfigurationRecordersInput, optFns ...func(*configservice.Options)) (*configservice.DescribeConfigurationRecordersOutput, error) {
 	return &m.DescribeConfigurationRecordersOutput, nil
 }
 
-func (m mockedConfigServiceRecorders) DeleteConfigurationRecorderWithContext(_ awsgo.Context, _ *configservice.DeleteConfigurationRecorderInput, _ ...request.Option) (*configservice.DeleteConfigurationRecorderOutput, error) {
+func (m mockedConfigServiceRecorders) DeleteConfigurationRecorder(ctx context.Context, params *configservice.DeleteConfigurationRecorderInput, optFns ...func(*configservice.Options)) (*configservice.DeleteConfigurationRecorderOutput, error) {
 	return &m.DeleteConfigurationRecorderOutput, nil
 }
 
 func TestConfigServiceRecorder_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-recorder-1"
@@ -37,7 +34,7 @@ func TestConfigServiceRecorder_GetAll(t *testing.T) {
 	csr := ConfigServiceRecorders{
 		Client: mockedConfigServiceRecorders{
 			DescribeConfigurationRecordersOutput: configservice.DescribeConfigurationRecordersOutput{
-				ConfigurationRecorders: []*configservice.ConfigurationRecorder{
+				ConfigurationRecorders: []types.ConfigurationRecorder{
 					{Name: aws.String(testName1)},
 					{Name: aws.String(testName2)},
 				},
@@ -70,13 +67,12 @@ func TestConfigServiceRecorder_GetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestConfigServiceRecorder_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	csr := ConfigServiceRecorders{
diff --git a/aws/resources/config_service_test.go b/aws/resources/config_service_test.go
index 4ebbbd1..966df5a 100644
--- a/aws/resources/config_service_test.go
+++ b/aws/resources/config_service_test.go
@@ -5,42 +5,38 @@ import (
 	"regexp"
 	"testing"
 
-	"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/configservice"
-	"github.com/aws/aws-sdk-go/service/configservice/configserviceiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/configservice"
+	"github.com/aws/aws-sdk-go-v2/service/configservice/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedConfigServiceRule struct {
-	configserviceiface.ConfigServiceAPI
+	ConfigServiceRuleAPI
 	DescribeConfigRulesOutput               configservice.DescribeConfigRulesOutput
-	DeleteConfigRuleOutput                  configservice.DeleteConfigRuleOutput
-	DeleteRemediationConfigurationOutput    configservice.DeleteRemediationConfigurationOutput
 	DescribeRemediationConfigurationsOutput configservice.DescribeRemediationConfigurationsOutput
+	DeleteRemediationConfigurationOutput    configservice.DeleteRemediationConfigurationOutput
+	DeleteConfigRuleOutput                  configservice.DeleteConfigRuleOutput
 }
 
-func (m mockedConfigServiceRule) DescribeConfigRulesPagesWithContext(_ awsgo.Context, _ *configservice.DescribeConfigRulesInput, fn func(*configservice.DescribeConfigRulesOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.DescribeConfigRulesOutput, true)
-	return nil
+func (m mockedConfigServiceRule) DescribeConfigRules(ctx context.Context, params *configservice.DescribeConfigRulesInput, optFns ...func(*configservice.Options)) (*configservice.DescribeConfigRulesOutput, error) {
+	return &m.DescribeConfigRulesOutput, nil
 }
 
-func (m mockedConfigServiceRule) DeleteConfigRuleWithContext(_ awsgo.Context, _ *configservice.DeleteConfigRuleInput, _ ...request.Option) (*configservice.DeleteConfigRuleOutput, error) {
-	return &m.DeleteConfigRuleOutput, nil
+func (m mockedConfigServiceRule) DescribeRemediationConfigurations(ctx context.Context, params *configservice.DescribeRemediationConfigurationsInput, optFns ...func(*configservice.Options)) (*configservice.DescribeRemediationConfigurationsOutput, error) {
+	return &m.DescribeRemediationConfigurationsOutput, nil
 }
 
-func (m mockedConfigServiceRule) DeleteRemediationConfigurationWithContext(_ awsgo.Context, _ *configservice.DeleteRemediationConfigurationInput, _ ...request.Option) (*configservice.DeleteRemediationConfigurationOutput, error) {
+func (m mockedConfigServiceRule) DeleteRemediationConfiguration(ctx context.Context, params *configservice.DeleteRemediationConfigurationInput, optFns ...func(*configservice.Options)) (*configservice.DeleteRemediationConfigurationOutput, error) {
 	return &m.DeleteRemediationConfigurationOutput, nil
 }
 
-func (m mockedConfigServiceRule) DescribeRemediationConfigurationsWithContext(_ awsgo.Context, _ *configservice.DescribeRemediationConfigurationsInput, _ ...request.Option) (*configservice.DescribeRemediationConfigurationsOutput, error) {
-	return &m.DescribeRemediationConfigurationsOutput, nil
+func (m mockedConfigServiceRule) DeleteConfigRule(ctx context.Context, params *configservice.DeleteConfigRuleInput, optFns ...func(*configservice.Options)) (*configservice.DeleteConfigRuleOutput, error) {
+	return &m.DeleteConfigRuleOutput, nil
 }
 
 func TestConfigServiceRule_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-rule-1"
@@ -48,9 +44,9 @@ func TestConfigServiceRule_GetAll(t *testing.T) {
 	csr := ConfigServiceRule{
 		Client: mockedConfigServiceRule{
 			DescribeConfigRulesOutput: configservice.DescribeConfigRulesOutput{
-				ConfigRules: []*configservice.ConfigRule{
-					{ConfigRuleName: aws.String(testName1), ConfigRuleState: aws.String("ACTIVE")},
-					{ConfigRuleName: aws.String(testName2), ConfigRuleState: aws.String("ACTIVE")},
+				ConfigRules: []types.ConfigRule{
+					{ConfigRuleName: aws.String(testName1), ConfigRuleState: types.ConfigRuleStateActive},
+					{ConfigRuleName: aws.String(testName2), ConfigRuleState: types.ConfigRuleStateActive},
 				},
 			},
 		},
@@ -81,13 +77,12 @@ func TestConfigServiceRule_GetAll(t *testing.T) {
 			})
 
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestConfigServiceRule_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	csr := ConfigServiceRule{
diff --git a/aws/resources/datasync_location_test.go b/aws/resources/datasync_location_test.go
index 2407d37..1191c13 100644
--- a/aws/resources/datasync_location_test.go
+++ b/aws/resources/datasync_location_test.go
@@ -5,32 +5,29 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/datasync"
-	"github.com/aws/aws-sdk-go/service/datasync/datasynciface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/datasync"
+	"github.com/aws/aws-sdk-go-v2/service/datasync/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 type mockDatasyncLocation struct {
-	datasynciface.DataSyncAPI
-	ListLocationsOutput  datasync.ListLocationsOutput
-	DeleteLocationOutput datasync.DeleteLocationOutput
+	DataSyncLocationAPI
+	datasync.DeleteLocationOutput
+	datasync.ListLocationsOutput
 }
 
-func (m mockDatasyncLocation) ListLocationsPagesWithContext(_ aws.Context, _ *datasync.ListLocationsInput, callback func(*datasync.ListLocationsOutput, bool) bool, _ ...request.Option) error {
-	callback(&m.ListLocationsOutput, true)
-	return nil
+func (m mockDatasyncLocation) DeleteLocation(ctx context.Context, params *datasync.DeleteLocationInput, optFns ...func(*datasync.Options)) (*datasync.DeleteLocationOutput, error) {
+	return &m.DeleteLocationOutput, nil
 }
 
-func (m mockDatasyncLocation) DeleteLocationWithContext(aws.Context, *datasync.DeleteLocationInput, ...request.Option) (*datasync.DeleteLocationOutput, error) {
-	return &m.DeleteLocationOutput, nil
+func (m mockDatasyncLocation) ListLocations(ctx context.Context, params *datasync.ListLocationsInput, optFns ...func(*datasync.Options)) (*datasync.ListLocationsOutput, error) {
+	return &m.ListLocationsOutput, nil
 }
 
 func TestDataSyncLocation_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "test-datasync-location"
@@ -45,7 +42,6 @@ func TestDataSyncLocation_NukeAll(t *testing.T) {
 }
 
 func TestDataSyncLocation_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-datasync-location-1"
@@ -53,7 +49,7 @@ func TestDataSyncLocation_GetAll(t *testing.T) {
 	location := DataSyncLocation{
 		Client: mockDatasyncLocation{
 			ListLocationsOutput: datasync.ListLocationsOutput{
-				Locations: []*datasync.LocationListEntry{
+				Locations: []types.LocationListEntry{
 					{
 						LocationArn: aws.String(fmt.Sprintf("arn::location/%s", testName1)),
 					},
@@ -80,7 +76,7 @@ func TestDataSyncLocation_GetAll(t *testing.T) {
 				DataSyncLocation: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
diff --git a/aws/resources/datasync_task_test.go b/aws/resources/datasync_task_test.go
index f0573af..5db0df1 100644
--- a/aws/resources/datasync_task_test.go
+++ b/aws/resources/datasync_task_test.go
@@ -6,32 +6,29 @@ 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/datasync"
-	"github.com/aws/aws-sdk-go/service/datasync/datasynciface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/datasync"
+	"github.com/aws/aws-sdk-go-v2/service/datasync/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 type mockDataSyncTask struct {
-	datasynciface.DataSyncAPI
-	ListTasksOutput  datasync.ListTasksOutput
+	DataSyncTaskAPI
 	DeleteTaskOutput datasync.DeleteTaskOutput
+	ListTasksOutput  datasync.ListTasksOutput
 }
 
-func (m mockDataSyncTask) ListTasksPagesWithContext(_ aws.Context, _ *datasync.ListTasksInput, callback func(*datasync.ListTasksOutput, bool) bool, _ ...request.Option) error {
-	callback(&m.ListTasksOutput, true)
-	return nil
+func (m mockDataSyncTask) DeleteTask(ctx context.Context, params *datasync.DeleteTaskInput, optFns ...func(*datasync.Options)) (*datasync.DeleteTaskOutput, error) {
+	return &m.DeleteTaskOutput, nil
 }
 
-func (m mockDataSyncTask) DeleteTaskWithContext(aws.Context, *datasync.DeleteTaskInput, ...request.Option) (*datasync.DeleteTaskOutput, error) {
-	return &m.DeleteTaskOutput, nil
+func (m mockDataSyncTask) ListTasks(ctx context.Context, params *datasync.ListTasksInput, optFns ...func(*datasync.Options)) (*datasync.ListTasksOutput, error) {
+	return &m.ListTasksOutput, nil
 }
 
 func TestDataSyncTask_NukeAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName := "test-datasync-task"
@@ -46,7 +43,6 @@ func TestDataSyncTask_NukeAll(t *testing.T) {
 }
 
 func TestDataSyncTask_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "test-task-1"
@@ -54,7 +50,7 @@ func TestDataSyncTask_GetAll(t *testing.T) {
 
 	task := DataSyncTask{Client: mockDataSyncTask{
 		ListTasksOutput: datasync.ListTasksOutput{
-			Tasks: []*datasync.TaskListEntry{
+			Tasks: []types.TaskListEntry{
 				{
 					Name:    &testName1,
 					TaskArn: aws.String(fmt.Sprintf("arn::%s", testName1)),
@@ -91,7 +87,7 @@ func TestDataSyncTask_GetAll(t *testing.T) {
 				DataSyncTask: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
diff --git a/aws/resources/dynamodb_test.go b/aws/resources/dynamodb_test.go
index 495ee9b..1b07926 100644
--- a/aws/resources/dynamodb_test.go
+++ b/aws/resources/dynamodb_test.go
@@ -6,39 +6,34 @@ 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/dynamodb/dynamodbiface"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
 	"github.com/gruntwork-io/cloud-nuke/config"
 	"github.com/stretchr/testify/require"
 )
 
 type mockedDynamoDB struct {
-	dynamodbiface.DynamoDBAPI
-	DescribeTableOutputMap map[string]dynamodb.DescribeTableOutput
-	ListTablesOutput       dynamodb.ListTablesOutput
-	DeleteTableOutput      dynamodb.DeleteTableOutput
+	DynamoDBAPI
+	ListTablesOutput    dynamodb.ListTablesOutput
+	DescribeTableOutput map[string]dynamodb.DescribeTableOutput
+	DeleteTableOutput   dynamodb.DeleteTableOutput
 }
 
-func (m mockedDynamoDB) ListTablesPagesWithContext(_ awsgo.Context, _ *dynamodb.ListTablesInput, fn func(*dynamodb.ListTablesOutput, bool) bool, _ ...request.Option) error {
-	fn(&m.ListTablesOutput, true)
-	return nil
+func (m mockedDynamoDB) ListTables(ctx context.Context, params *dynamodb.ListTablesInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ListTablesOutput, error) {
+	return &m.ListTablesOutput, nil
 }
 
-func (m mockedDynamoDB) DescribeTableWithContext(_ awsgo.Context, input *dynamodb.DescribeTableInput, _ ...request.Option) (*dynamodb.DescribeTableOutput, error) {
-	output := m.DescribeTableOutputMap[*input.TableName]
+func (m mockedDynamoDB) DescribeTable(ctx context.Context, params *dynamodb.DescribeTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DescribeTableOutput, error) {
+	output := m.DescribeTableOutput[*params.TableName]
 	return &output, nil
 }
 
-func (m mockedDynamoDB) DeleteTableWithContext(_ awsgo.Context, _ *dynamodb.DeleteTableInput, _ ...request.Option) (*dynamodb.DeleteTableOutput, error) {
+func (m mockedDynamoDB) DeleteTable(ctx context.Context, params *dynamodb.DeleteTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DeleteTableOutput, error) {
 	return &m.DeleteTableOutput, nil
 }
 
 func TestDynamoDB_GetAll(t *testing.T) {
-
 	t.Parallel()
 
 	testName1 := "table1"
@@ -47,20 +42,20 @@ func TestDynamoDB_GetAll(t *testing.T) {
 	ddb := DynamoDB{
 		Client: mockedDynamoDB{
 			ListTablesOutput: dynamodb.ListTablesOutput{
-				TableNames: []*string{
-					aws.String(testName1),
-					aws.String(testName2),
+				TableNames: []string{
+					testName1,
+					testName2,
 				},
 			},
-			DescribeTableOutputMap: map[string]dynamodb.DescribeTableOutput{
+			DescribeTableOutput: map[string]dynamodb.DescribeTableOutput{
 				testName1: {
-					Table: &dynamodb.TableDescription{
+					Table: &types.TableDescription{
 						TableName:        aws.String(testName1),
 						CreationDateTime: aws.Time(now),
 					},
 				},
 				testName2: {
-					Table: &dynamodb.TableDescription{
+					Table: &types.TableDescription{
 						TableName:        aws.String(testName2),
 						CreationDateTime: aws.Time(now.Add(1)),
 					},
@@ -100,15 +95,13 @@ func TestDynamoDB_GetAll(t *testing.T) {
 				DynamoDB: tc.configObj,
 			})
 			require.NoError(t, err)
-			require.Equal(t, tc.expected, aws.StringValueSlice(names))
+			require.Equal(t, tc.expected, aws.ToStringSlice(names))
 		})
 	}
 }
 
 func TestDynamoDb_NukeAll(t *testing.T) {
-
 	t.Parallel()
-
 	ddb := DynamoDB{
 		Client: mockedDynamoDB{
 			DeleteTableOutput: dynamodb.DeleteTableOutput{},