Nowadays, cloud computing has been involved in almost all application development. Many big and startup companies prefer to use the cloud as it is very efficient and easy to set up their infrastructure. When it comes to Java development, Spring and Spring boot frameworks have been preferred by many developers as well as companies. In this article, we are going to discuss what Spring Cloud AWS is and how we can integrate a few AWS services in a Spring ecosystem using Spring Cloud AWS.

Spring Cloud AWS is an open-source project developed for integrating AWS services in a spring ecosystem. It gives an efficient way to integrate AWS services by applying spring-based idioms. Through Spring Cloud AWS, we can add starter dependencies of desired AWS managed service, just like we add the Spring Boot starter project, and the rest will be autoconfigured and we can leverage spring-based idioms in our project.

Key Terminologies Related to Spring AWS Cloud

The following are the key terminologies related to spring AWS Cloud:

• Spring Cloud: Spring Cloud is the framework used to build some patterns in distributed systems including configuration management, Service discovery, etc.
• AWS: Amazon Web Services is a cloud provider that provides various services including SQS ( Simple Queue Service ), S3(Simple Storage Service), Secrets Manager, etc.
• AWS SDK: It is a set of libraries to integrate or call various AWS-managed services. Through the help of SDK we can make integration programmatically.
• Spring Boot and Auto Configurations: Spring boot is built on top of the Spring framework which provides auto configurations. Through Spring boot we can develop efficient applications with less boilerplate code.
• Spring Cloud AWS: It is a framework used to integrate some AWS-managed services in a spring ecosystem. It requires considerably less code to integrate AWS services.

Why do we need to use Spring Cloud AWS?

AWS has already provided Java SDK for developers to integrate AWS services, though developers need a considerable amount of infrastructure-related code. Spring Cloud AWS provides all these infrastructure-related codes in Spring-based modules. There are several Spring-based modules specific to AWS services, so developers can add those specific Spring-based modules in the application based on their need for the particular service.

In the below graphical diagram, it is mentioned a few AWS managed services and their related Spring Cloud AWS components.

The below are the spring based modules, in the form of starter project, given by Spring Cloud AWS

• Spring Cloud AWS starter is a core module of Spring Cloud AWS and it provides basic services for security and configuration setup. Developers can’t use this module directly but rather through other modules. It automatically configures authentication and region selection.
• Spring Cloud AWS starter S3 provides integration with AWS S3 service.
• Spring Cloud AWS starter DynamoDB provides integration with AWS DynamoDB.
• Spring Cloud AWS starter SQS provides integration with SQS service.
• Spring Cloud AWS starter Secrets Manager provides integration with Secrets manager service. Which is used to store all confidential information in this service so developers cant expose secrets in source code.

Let’s get started by creating a project from scratch and adding spring based modules step by step and utilizing Spring Cloud AWS to integrate AWS managed service.

How to get started with Spring cloud AWS?

The following are the steps that guides you on how to get started with spring cloud AWS:

Step: 1 Initially lets create a new Maven project and add below Spring Cloud AWS Bills of Material(BOM) in pom.xml which declares recommended versions of all dependencies used by a given release of Spring Cloud AWS.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-dependencies</artifactId>
            <version>${project-version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

• Here Spring Cloud AWS group id is io.awspring.cloud and artifact is spring-cloud-aws-dependencies and here the latest version of Spring Cloud AWS on the current date is 3.1.0

Step 2: We need to add core dependency to integrate the AWS services, this module uses AwsCredentialsProvider and AwsRegionProvider to get the AWS region and access credentials.

• Also if we want to add a newer version of AWS SDK in our project than that is declared in Spring Cloud AWS then it is recommended to use below BOM to the dependency management section in pom.xml as mentioned below.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>${aws-java-sdk.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

• Here we can replace the latest AWS SDK version in the property aws-java-sdk.version.

Before using any AWS service in the project it is recommended to add AWS credentials in below places whatever suits you.

• Java System Properties – aws.accessKeyId and aws.secretAccessKey
• Environment Variables – AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY
• Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI

For this demo purpose we set the credentials in ~/.aws/credentials file.

Step: 1 Go to ~/.aws/credentials folder

Step 2: Open credentials file underneath .aws folder

Step 3: Set the aws_access_key_id and aws_secret_access_key in the credential file. In below screenshot replace your access key id and secret key id and region.

By default, Spring Cloud AWS starter auto-configures a DefaultCredentialsProvider, which looks for AWS credentials in this order:

• Java System Properties – aws.accessKeyId and aws.secretAccessKey
• Environment Variables – AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY
• Web Identity Token credentials from system properties or environment variables
• Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
• Credentials delivered through the Amazon EC2 container service if `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`” environment variable is set and security manager has permission to access the variable,
• Instance profile credentials delivered through the Amazon EC2 metadata service

Below is the basic pom.xml file to setup Spring Cloud AWS

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.1</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.danech</groupId>
    <artifactId>spring-cloud-aws</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-cloud-aws</name>
    <description>spring-cloud-aws</description>
    <properties>
        <java.version>17</java.version>
        <project-version>3.0.4</project-version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.awspring.cloud</groupId>
                <artifactId>spring-cloud-aws-dependencies</artifactId>
                <version>${project-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

• We have successfully set up the project of Spring Cloud AWS and we can now add its spring based module in the project.
• Lets understand a few spring based modules of Spring Cloud AWS how it will help in integrating AWS managed services in spring ecosystem. Let’s start with the Secrets Manager service.

AWS Secrets Manager Integration

It is an AWS service used to store all confidential values. As a programmer we should never hard-code the password and API keys in source code. In a Spring based project we can easily achieve this using Spring Cloud AWS secrets manager starter module. Lets achieve this in a step-by-step manner.

Step 1: Add Spring Cloud AWS secrets manager starter dependencies in our existing Spring Cloud AWS setup project as we have already discussed above.

<dependency>
    <groupId>io.awspring.cloud</groupId>
    <artifactId>spring-cloud-aws-starter-secrets-manager</artifactId>
</dependency>

Step 2: To fetch secrets from Secrets Manager and add them to Spring’s environment properties, add spring.config.import property to application.properties as below.

spring.config.import=aws-secretsmanager:/secrets/api-key

• Here /secrets/api-key is the name of the secrets in Secrets Manager in AWS.
• If we want to load multiple secrets then we have to separate the names with “;” as below.

spring.config.import=aws-secretsmanager:/secrets/api-key; 
/secrets/db-password;/secrets/token-secret-key

• If a secret with a given name does not exist then the application will fail to start, if we want to make the name as optional and start the application regardless of the secret name then we can use optional prefix in the configuration as below.

spring.config.import=optional:aws-secretsmanager:/secrets/api-key

Step 3: In a standard Spring based application @Value is used for property-driven dependency injection.

• In the same way we just need to pass the secret key name in a spEL (Spring Expression Language) style format in @Value annotation and we will get the value of the secret key from Secrets Manager AWS service. Sample example is mentioned as below

@Value("${username}"
private String username;

@Value("${password}"
private String password;

• So inside the secret name in Secrets Manager AWS service we can mention key-value pairs as mentioned below from the AWS console.

• So we have learnt successfully about how we can utilize Secrets Manager AWS service in a spring ecosystem using Spring Cloud AWS.
• Here is the full basic code which includes pom.xml and Main method

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.1</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.danech</groupId>
    <artifactId>spring-cloud-aws</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-cloud-aws</name>
    <description>spring-cloud-aws</description>
    <properties>
        <java.version>17</java.version>
        <project-version>3.0.4</project-version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter-secrets-manager</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.awspring.cloud</groupId>
                <artifactId>spring-cloud-aws-dependencies</artifactId>
                <version>${project-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package com.danech;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

@SpringBootApplication
@Component
public class SpringCloudAwsApplication implements CommandLineRunner{
    
    @Value("${rag-db-cred}")
    private String secretKey;
    
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudAwsApplication.class, args);
    }
    
    @Override
    public void run(String... args) throws Exception {
        System.out.println(secretKey);
    }

}

• 
  Let’s get the secrets key-value in our Spring based application from AWS Secretes Manager service. Let’s follow the below steps.

Step 1: Create the secret key value from AWS Console. Choose a secrete type as “Other type of secret”.

Step 2: Now give the secret name as mentioned below

Step 3: Now in application.properties add below properties

Step 4: Now after running our project from CommandLineRunner we will get the below mentioned output.

AWS SQS Integration

• Simple Queue Service is a messaging service that provides point to point communication with queues. Spring Cloud AWS SQS module supports receiving and sending messages using common spring idioms.

• Let me demonstrate how Spring Cloud AWS provides auto-configurations and how we can configure SQS service in spring based applications. Let’s understand it step-by-step.

Step 1: Add below Spring Cloud AWS sqs starter dependency in our existing Spring Cloud AWS project. Which gives basic SQS configurations.

<dependency>
    <groupId>io.awspring.cloud</groupId>
    <artifactId>spring-cloud-aws-starter-sqs</artifactId>
</dependency>

Step 2: Lets create a queue in AWS SQS service and send a message to that Queue. As mentioned below we have successfully sent a message to queue named “myQueue”

Step 3: Lets receive a message using @SqsListener and it will make developer’s life easy, a small snippet shows we can leverage Spring Cloud AWS sqs module in existing Spring Boot project.

@SpringBootApplication
public class SqsApplication {

    public static void main(String[] args) {
        SpringApplication.run(SqsApplication.class, args);
    }
  
    @SqsListener("myQueue")
    public void listen(String message) {
        System.out.println(message);
    }
}

• We have successfully received a message from SQS AWS service in our Spring Boot application.

Step 4: Let’s send a message using SqsTemplate class. In Spring boot application it is autowired default in case no other template bean is found in the context.

@Autowired
SqsTemplate gfgSqsTemplate;

SendResult<String> result = gfgSqsTemplate.send(to -> to.queue("myQueue")
    .payload("myPayload")
    .header("myHeaderName", "myHeaderValue")
    .headers(Map.of("myOtherHeaderName", "myOtherHeaderValue"))
    .delaySeconds(10)
);

• So we have successfully sent a message on queue on SQS service using Spring idioms using Spring Cloud AWS.
• Below is basic full code to receive a message from SQS service in Spring Cloud AWS project.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.1</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.danech</groupId>
    <artifactId>spring-cloud-aws</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-cloud-aws</name>
    <description>spring-cloud-aws</description>
    <properties>
        <java.version>17</java.version>
        <project-version>3.0.4</project-version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter-sqs</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.awspring.cloud</groupId>
                <artifactId>spring-cloud-aws-dependencies</artifactId>
                <version>${project-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

package com.danech;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

import io.awspring.cloud.sqs.annotation.SqsListener;

@SpringBootApplication
@Component
public class SpringCloudAwsApplication{
        
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudAwsApplication.class, args);
    }
    
    @SqsListener("myQueue")
    public void listen(String message) {
        System.out.println(message);
    }
}

• Let’s send a message from AWS Console and it will be received in out method.

How to Create Amazon SQS?

Step 1: Create a Standard queue

Step 2: After creating click on Send and receive message button

Step 4: Now write a message and click on Send message Button.

Step 5: As soon as we send a message we will get the message in our application. Through the listener method we will get the message on our IDE console as mentioned below.

AWS S3 Integration

Simple storage service is provided by AWS to store different types of objects/files in the AWS cloud. Spring Cloud AWS s3 starter supports reading and writing objects on S3. We can leverage auto configuration using the starter component. Using Spring Cloud AWS S3 module we can integrate S3 service in spring style.

Integration of Spring Application With AWS Cloud

Step 1: Add s3 starter dependency in pom.xml as below in the existing Spring Cloud AWS project.

<dependency>
    <groupId>io.awspring.cloud</groupId>
    <artifactId>spring-cloud-aws-starter-s3</artifactId>
</dependency>

Step 2: After adding the dependency we can get all classes related to S3 services. The starter automatically configures and registers a S3Client bean in the Spring application context. Below is the example used to read the text file from S3 bucket.

@Component
class GfGS3ClientSample {
    private final S3Client gfgS3Cleint;

    S3ClientSample(S3Client gfgS3Cleint) {
        this.gfgS3Cleint = gfgS3Cleint;
    }

    void readFileContent() throws IOException {
        ResponseInputStream<GetObjectResponse> response = gfgS3Cleint.getObject(
            request -> request.bucket("bucket-name").key("file-name.txt"));

        String fileContent = StreamUtils.copyToString(response, StandardCharsets.UTF_8);

        System.out.println(fileContent);
    }
}

• In the above snippet we can read the file from S3 bucket, in a spring based manner, without any configurations.

Step 3: In addition we can also add Spring Resource to access S3 by S3 URL as below. Spring Resource is an abstract for all low level resources like file system, classpath files etc.

@Value("s3://[S3_BUCKET_NAME]/[FILE_NAME]")
private Resource s3Resource;

• Below snippet is used to write a file content to S3 bucket in the mentioned S3_BUCKET_NAME and FILE_NAME

@Value("s3://[S3_BUCKET_NAME]/[FILE_NAME]")
private Resource s3Resource;
//...
try (OutputStream os = ((WritableResource) s3Resource).getOutputStream()) {
  os.write("content".getBytes());
}

• The S3 integration can be achieved with considerably less amount of code using Spring Cloud AWS.
• Below is the full code to read the S3 file in a spring style way using Spring Resource

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.1</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.danech</groupId>
    <artifactId>spring-cloud-aws</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-cloud-aws</name>
    <description>spring-cloud-aws</description>
    <properties>
        <java.version>17</java.version>
        <project-version>3.0.4</project-version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>io.awspring.cloud</groupId>
            <artifactId>spring-cloud-aws-starter-s3</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.awspring.cloud</groupId>
                <artifactId>spring-cloud-aws-dependencies</artifactId>
                <version>${project-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package com.danech;

import java.nio.charset.StandardCharsets;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Component;
import org.springframework.util.StreamUtils;

@SpringBootApplication
@Component
public class SpringCloudAwsApplication implements CommandLineRunner {

    @Value("s3://spring-cloud-aws-s3/Spring_Cloud_AWS_S3.txt")
    private Resource resource;

    public static void main(String[] args) {
        SpringApplication.run(SpringCloudAwsApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        String fileData = StreamUtils.copyToString(resource.getInputStream(), StandardCharsets.UTF_8);
        System.out.println(fileData);
    }

}

• Let’s do the practical for the same as mentioned in below steps.

Step 4: Create a S3 bucket from AWS Console and named it “spring-cloud-aws-s3”.

Step 5: Now create a text file and place it under the S3 bucket. Put the text file content as “This is Spring Cloud AWS S3 module for reading”.

• The following screenshot illustrates the successful upload of the file in the Amazon S3 Bucket:

Step 3: Now let’s read the file content through CommandLineRunner, we will get below output as mentioned.

Conclusion

In this article We have seen what Spring Cloud AWS is and how Spring Cloud AWS helps to integrate AWS managed services in the spring ecosystem. We have seen graphical representation of Spring Cloud AWS modules and AWS Managed services. Also we have seen how to integrate some AWS managed services in Spring based projects leveraging auto configuration with less boilerplate code required in integration.

Spring AWS Cloud – FAQs

What is the need of Spring Cloud AWS?

Though we have Java SDK available from AWS, we need to write a considerable amount of code to integrate the services. Spring Cloud AWS gives integration in a more efficient way without any boilerplate code.

I have a Spring boot application already, can I integrate the Spring Cloud AWS in the existing Spring boot project?

Yes, but it is recommended to check the compatibility of Spring boot and Spring Cloud AWS. It is recommended to check the official github site for Spring Cloud AWS.

What is the difference between Spring Cloud and Spring Cloud AWS?

Spring Cloud is the framework used to build some patterns in distributed systems including configuration management, Service discovery etc. On the other hand, Spring Cloud AWS used to integrate AWS managed services in Spring based idioms.

What is the use of the spring cloud aws starter dependency?

This dependency is required to get the credentials and region of your aws service. It uses spring-cloud-aws-autoconfigure, spring-cloud-aws-core and spring-boot-starter dependency to auto-configure the other modules.

How to provide a different/newer version of AWS Java SDK rather than using the version which spring cloud aws used?

AWS Java SDK is released more than Spring cloud aws. If we need to use newer version or a different version than the one configured by Spring Cloud AWS, add the SDK BOM to the dependency management section making sure it is declared before any other BOM dependency that configures AWS SDK dependencies.