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>
Copy to clipboard

dependencies {
  implementation platform("io.awspring.cloud:spring-cloud-aws-dependencies:${springCloudAwsVersion}")
  // Replace the following with the starter dependencies of specific modules you wish to use
  implementation 'io.awspring.cloud:spring-cloud-aws-starter-sqs'
}
Copy to clipboard

<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>
Copy to clipboard

public interface AwsCredentialsProvider {
    AwsCredentials resolveCredentials();
}
Copy to clipboard

logging.level.io.awspring.cloud=debug
Copy to clipboard

public interface AwsRegionProvider {
    Region getRegion();
}
Copy to clipboard

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import software.amazon.awssdk.regions.providers.AwsRegionProvider;

@Configuration
class CustomRegionProviderConfiguration {

    @Bean
    public AwsRegionProvider customRegionProvider() {
        return new CustomRegionProvider();
    }
}
Expand folded textCopy to clipboard

import io.awspring.cloud.autoconfigure.AwsSyncClientCustomizer;

@Bean
AwsSyncClientCustomizer awsSyncClientCustomizer() {
    return builder -> {
        builder.httpClient(ApacheHttpClient.builder().connectionTimeout(Duration.ofSeconds(1)).build());
    };
}
Expand folded textCopy to clipboard

@Bean
AwsAsyncClientCustomizer awsAsyncClientCustomizer() {
    return builder -> {
        builder.httpClient(NettyNioAsyncHttpClient.builder().connectionTimeout(Duration.ofSeconds(1)).build());
    };
}
Copy to clipboard

import java.util.UUID;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;

@DynamoDbBean
public class Person {
    private UUID id;
    private String name;
    private String lastName;

    @DynamoDbPartitionKey
    public UUID getId() {
        return id;
    }

    ...
}
Expand folded textCopy to clipboard

import io.awspring.cloud.dynamodb.DynamoDbTemplate;

...
@Autowired
DynamoDbTemplate dynamoDbTemplate;
...
Person person = new Person(...)
dynamoDbTemplate.save(person);
Expand folded textCopy to clipboard

import java.util.Collections;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DeleteItemRequest;

public class DynamoDbService {
    private final DynamoDbClient dynamoDbClient;

    public DynamoDbService(DynamoDbClient dynamoDbClient) {
        this.dynamoDbClient = dynamoDbClient;
    }

    void deletePerson(String uuid) {
        dynamoDbClient.deleteItem(DeleteItemRequest.builder().key(Collections.singletonMap("uuid", AttributeValue.builder().s(uuid).build())).build());
    }
}
Expand folded textCopy to clipboard

<dependency>
    <groupId>software.amazon.dax</groupId>
    <artifactId>amazon-dax-client</artifactId>
</dependency>
Copy to clipboard

@Bean
DynamoDbClientCustomizer customizer() {
    return builder -> {
        builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
            c.apiCallTimeout(Duration.ofMillis(1500));
        }));
    };
}
Copy to clipboard

import java.io.IOException;
import java.nio.charset.StandardCharsets;

import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;

import org.springframework.stereotype.Component;
import org.springframework.util.StreamUtils;

@Component
class S3ClientSample {
    private final S3Client s3Client;

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

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

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

        System.out.println(fileContent);
    }
}
Expand folded textCopy to clipboard

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3-transfer-manager</artifactId>
</dependency>
Copy to clipboard

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>aws-crt-client</artifactId>
</dependency>
Copy to clipboard

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

SpringApplication.run(...).getResource("s3://[S3_BUCKET_NAME]/[FILE_NAME]");
Copy to clipboard

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

@Value("s3://[S3_BUCKET_NAME]/[FILE_NAME]")
private Resource s3Resource;
...
ObjectMetadata objectMetadata = ObjectMetadata.builder()
    .contentType("application/json")
    .serverSideEncryption(ServerSideEncryption.AES256)
    .build();
s3Resource.setObjectMetadata(objectMetadata);
try (OutputStream outputStream = s3Resource.getOutputStream()) {
    outputStream.write("content".getBytes(StandardCharsets.UTF_8));
}
Copy to clipboard

<dependency>
    <groupId>software.amazon.encryption.s3</groupId>
    <artifactId>amazon-s3-encryption-client-java</artifactId>
</dependency>
Copy to clipboard

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>kms</artifactId>
    <optional>true</optional>
 </dependency>
Copy to clipboard

import io.awspring.cloud.autoconfigure.s3.S3RsaProvider;
import java.security.KeyPair;
import java.security.KeyPairGenerator;

public class MyRsaProvider implements S3RsaProvider {
    @Override
    public KeyPair generateKeyPair() {
        try {
            // fetch key pair from secure location such as Secrets Manager
            // access to KeyPair is required to decrypt objects when fetching, so it is advised to keep them stored securely
        }
        catch (Exception e) {
            return null;
        }
    }
}
Expand folded textCopy to clipboard

import io.awspring.cloud.autoconfigure.s3.S3AesProvider;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

public class MyAesProvider implements S3AesProvider {
    @Override
    public SecretKey generateSecretKey() {
        try {
            // fetch secret key from secure location such as Secrets Manager
            // access to secret key is required to decrypt objects when fetching, so it is advised to keep them stored securely
        }
        catch (Exception e) {
            return null;
        }
    }
}
Expand folded textCopy to clipboard

<dependency>
    <groupId>software.amazon.s3.accessgrants</groupId>
    <artifactId>aws-s3-accessgrants-java-plugin</artifactId>
</dependency>
Copy to clipboard

@Autowired
private S3Template s3Template;

InputStream is = ...
// uploading file without metadata
s3Template.upload(BUCKET, "file.txt", is);

// uploading file with metadata
s3Template.upload(BUCKET, "file.txt", is, ObjectMetadata.builder().contentType("text/plain").build());
Copy to clipboard

URL signedGetUrl = s3Template.createSignedGetURL("bucket_name", "file.txt", Duration.ofMinutes(5));
Copy to clipboard

Person p = new Person("John", "Doe");
s3Template.store(BUCKET, "person.json", p);

Person loadedPerson = s3Template.read(BUCKET, "person.json", Person.class);
Copy to clipboard

@Bean
S3ClientCustomizer customizer() {
    return builder -> {
        builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
            c.apiCallTimeout(Duration.ofMillis(1500));
        }));
    };
}
Copy to clipboard

spring.config.import=aws-s3:/bucket-name/config.properties
Copy to clipboard

spring.config.import=optional:aws-s3:/bucket-name/config.properties
Copy to clipboard

spring.config.import=aws-s3:/bucket-name/config.properties;/another-name/config.yml
Copy to clipboard

spring.config.import[0]=optional:bucket-name/config.properties
spring.config.import[1]=aws-s3=/another-name/config.yml
Copy to clipboard

{
      "url": "someUrl"
}
Copy to clipboard

spring.config.import=aws-s3:/bucket-name/config.json
Copy to clipboard

@Value("${url}"
private String url;
Copy to clipboard

package com.app;

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;

import org.springframework.boot.BootstrapRegistry;
import org.springframework.boot.BootstrapRegistryInitializer;

public class S3ClientBootstrapConfiguration implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        registry.register(S3Client.class, context -> {
            AwsCredentialsProvider awsCredentialsProvider = StaticCredentialsProvider.create(AwsBasicCredentials.create("yourAccessKey", "yourSecretKey"));
            return S3Client.builder().credentialsProvider(awsCredentialsProvider).region(Region.EU_WEST_2).build();
        });
    }
}
Expand folded textCopy to clipboard

org.springframework.boot.BootstrapRegistryInitializer=com.app.S3ClientBootstrapConfiguration
Copy to clipboard

package com.app;

import io.awspring.cloud.autoconfigure.s3.S3ClientCustomizer;
import java.time.Duration;
import org.springframework.boot.BootstrapRegistry;
import org.springframework.boot.BootstrapRegistryInitializer;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;

class S3ClientBootstrapConfiguration implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        registry.register(S3ClientCustomizer.class, context -> (builder -> {
            builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
                c.apiCallTimeout(Duration.ofMillis(2001));
            }));
        }));
    }
}
Expand folded textCopy to clipboard

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-commons</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-context</artifactId>
</dependency>
Copy to clipboard

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:ListBucket",
            "Resource": "arn:aws:s3:::spring-cloud-aws-demo"
        },
        {
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::spring-cloud-aws-demo/*"
        },
        {
            "Effect": "Allow",
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::spring-cloud-aws-demo/*"
        }
    ]
}
Copy to clipboard

import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;

class MailSendingService {

    private final MailSender mailSender;

    public MailSendingService(MailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void sendMailMessage() {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom("foo@bar.com");
        simpleMailMessage.setTo("bar@baz.com");
        simpleMailMessage.setSubject("test subject");
        simpleMailMessage.setText("test content");
        this.mailSender.send(simpleMailMessage);
    }
}
Expand folded textCopy to clipboard

<dependency>
    <groupId>jakarta.mail</groupId>
    <artifactId>jakarta.mail-api</artifactId>
</dependency>
<dependency>
    <groupId>org.eclipse.angus</groupId>
    <artifactId>jakarta.mail</artifactId>
</dependency>
Copy to clipboard

import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.mail.javamail.MimeMessagePreparator;

class MailSendingService {

    private final JavaMailSender mailSender;

    public MailSendingService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void sendMailMessage() {
        this.mailSender.send(new MimeMessagePreparator() {

            @Override
            public void prepare(MimeMessage mimeMessage) throws Exception {
                MimeMessageHelper helper =
                    new MimeMessageHelper(mimeMessage, true, "UTF-8");
                helper.addTo("foo@bar.com");
                helper.setFrom("bar@baz.com");
                helper.addAttachment("test.txt", ...);
                helper.setSubject("test subject with attachment");
                helper.setText("mime body", false);
            }
        });
    }
}
Expand folded textCopy to clipboard

spring.cloud.aws.ses.region=eu-west-1
spring.cloud.aws.ses.source-arn=arn:aws:ses:eu-west-1:123456789012:identity/example.com
spring.cloud.aws.ses.from-arn=arn:aws:ses:eu-west-1:123456789012:identity/example.com
spring.cloud.aws.ses.configuration-set-name=ConfigSet
Copy to clipboard

@Bean
SesClientCustomizer customizer() {
    return builder -> {
        builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
            c.apiCallTimeout(Duration.ofMillis(1500));
        }));
    };
}
Copy to clipboard

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ses:SendEmail",
                "ses:SendRawEmail"
            ],
            "Resource": "arn:aws:ses:your:arn"
        }
    ]
}
Copy to clipboard

import io.awspring.cloud.sns.sms.SmsMessageAttributes;
import io.awspring.cloud.sns.sms.SmsType;
import io.awspring.cloud.sns.sms.SnsSmsTemplate;

class NotificationService {
    private SnsSmsTemplate smsTemplate;

    NotificationService(SnsSmsTemplate smsTemplate) {
        this.smsTemplate = smsTemplate;
    }

    void sendSms() {
        smsTemplate.send("+1XXX5550100", "the message", SmsMessageAttributes.builder()
                .smsType(SmsType.PROMOTIONAL).senderID("mySenderID").maxPrice("0.50").build());
    }
}
Expand folded textCopy to clipboard

import software.amazon.awssdk.services.sns.SnsClient;

class NotificationService {
    private final SnsClient snsClient;

    public NotificationService(SnsClient snsClient) {
        this.snsClient = snsClient;
    }

    void sendNotification() {
        snsClient.publish(request -> request.topicArn("sns-topic-arn").message("payload"));
    }
}
Expand folded textCopy to clipboard

import io.awspring.cloud.sns.annotation.endpoint.NotificationMessageMapping;
import io.awspring.cloud.sns.annotation.endpoint.NotificationSubscriptionMapping;
import io.awspring.cloud.sns.annotation.endpoint.NotificationUnsubscribeConfirmationMapping;
import io.awspring.cloud.sns.annotation.handlers.NotificationMessage;
import io.awspring.cloud.sns.annotation.handlers.NotificationSubject;
import io.awspring.cloud.sns.handlers.NotificationStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/topicName")
public class NotificationTestController {

    @NotificationSubscriptionMapping
    public void handleSubscriptionMessage(NotificationStatus status) {
        //We subscribe to start receive the message
        status.confirmSubscription();
    }

    @NotificationMessageMapping
    public void handleNotificationMessage(@NotificationSubject String subject, @NotificationMessage String message) {
        // ...
    }

    @NotificationUnsubscribeConfirmationMapping
    public void handleUnsubscribeMessage(NotificationStatus status) {
        //e.g. the client has been unsubscribed and we want to "re-subscribe"
        status.confirmSubscription();
    }
}
Expand folded textCopy to clipboard

@Bean
SnsClientCustomizer customizer() {
    return builder -> {
        builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
            c.apiCallTimeout(Duration.ofMillis(1500));
        }));
    };
}
Copy to clipboard

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sns:Publish",
                "sns:ConfirmSubscription",
                "sns:GetTopicAttributes"
            ],
            "Resource": "yourArn"
        },
        {
            "Effect": "Allow",
            "Action": "sns:ListTopics",
            "Resource": "*"
        },
        {
        "Effect": "Allow",
        "Action": "sns:CreateTopic",
        "Resource": "*"
        }
    ]
}
Copy to clipboard

@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);
    }
}
Copy to clipboard

public class Listener {

    @SqsListener("myQueue")
    public void listen(String message) {
        System.out.println(message);
    }

}

@Import(SqsBootstrapConfiguration.class)
@Configuration
public class SQSConfiguration {

    @Bean
    public SqsMessageListenerContainerFactory<Object> defaultSqsListenerContainerFactory() {
        return SqsMessageListenerContainerFactory
            .builder()
            .sqsAsyncClient(sqsAsyncClient())
            .build();
    }

    @Bean
    public SqsAsyncClient sqsAsyncClient() {
        return SqsAsyncClient.builder().build();
    }

    @Bean
    public Listener listener() {
        return new Listener();
    }

}
Copy to clipboard

public interface MessageInterceptor<T> {

    default Message<T> intercept(Message<T> message) {
        return message;
    }

    default Collection<Message<T>> intercept(Collection<Message<T>> messages) {
        return messages;
    }

    default void afterProcessing(Message<T> message, Throwable t) {
    }

    default void afterProcessing(Collection<Message<T>> messages, Throwable t) {
    }

}
Copy to clipboard

public interface AsyncMessageInterceptor<T> {

    default CompletableFuture<Message<T>> intercept(Message<T> message) {
        return CompletableFuture.completedFuture(message);
    }

    default CompletableFuture<Collection<Message<T>>> intercept(Collection<Message<T>> messages) {
        return CompletableFuture.completedFuture(messages);
    }

    default CompletableFuture<Void> afterProcessing(Message<T> message, Throwable t) {
        return CompletableFuture.completedFuture(null);
    }

    default CompletableFuture<Void> afterProcessing(Collection<Message<T>> messages, Throwable t) {
        return CompletableFuture.completedFuture(null);
    }

}
Copy to clipboard

@Bean
public MessageInterceptor<Object> messageInterceptor() {
    return new MessageInterceptor<Object>() {
            @Override
            public Message<Object> intercept(Message<Object> message) {
                return MessageBuilder
                    .fromMessage(message)
                    .setHeader("newHeader", "newValue")
                    .build();
            }
        };
}
Copy to clipboard

@Bean
public SqsMessageListenerContainerFactory<Object> defaultSqsListenerContainerFactory() {
    return SqsMessageListenerContainerFactory
        .builder()
        .sqsAsyncClientSupplier(BaseSqsIntegrationTest::createAsyncClient)
        .messageInterceptor(new MessageInterceptor<Object>() {
            @Override
            public Message<Object> intercept(Message<Object> message) {
                return MessageBuilder
                    .fromMessage(message)
                    .setHeader("newHeader", "newValue")
                    .build();
            }
        })
        .build();
}
Copy to clipboard

public interface ErrorHandler<T> {

    default void handle(Message<T> message, Throwable t) {
    }

    default void handle(Collection<Message<T>> messages, Throwable t) {
    }

}
Copy to clipboard

public interface AsyncErrorHandler<T> {

    default CompletableFuture<Void> handle(Message<T> message, Throwable t) {
        return CompletableFutures.failedFuture(t);
    }

    default CompletableFuture<Void> handle(Collection<Message<T>> messages, Throwable t) {
        return CompletableFutures.failedFuture(t);
    }

}
Copy to clipboard

@Bean
public ErrorHandler<Object> errorHandler() {
    return new ErrorHandler<Object>() {
        @Override
        public void handle(Message<Object> message, Throwable t) {
            // error handling logic
            // throw if the message should not be acknowledged
        }
    }}
Copy to clipboard

@Bean
public SqsMessageListenerContainerFactory<Object> defaultSqsListenerContainerFactory() {
    return SqsMessageListenerContainerFactory
        .builder()
        .sqsAsyncClientSupplier(BaseSqsIntegrationTest::createAsyncClient)
        .errorHandler(new ErrorHandler<Object>() {
            @Override
            public void handle(Message<Object> message, Throwable t) {
                // error handling logic
            }
        })
        .build();
}
Copy to clipboard

@Bean
SqsMessageListenerContainerFactory<Object> defaultSqsListenerContainerFactory(SqsAsyncClient sqsAsyncClient) {
    return SqsMessageListenerContainerFactory
            .builder()
            .configure(options -> options
                    .acknowledgementMode(AcknowledgementMode.ALWAYS)
                    .acknowledgementInterval(Duration.ofSeconds(3))
                    .acknowledgementThreshold(5)
                    .acknowledgementOrdering(AcknowledgementOrdering.ORDERED)
            )
            .sqsAsyncClient(sqsAsyncClient)
            .build();
}
Copy to clipboard

@FunctionalInterface
public interface SqsListenerConfigurer {

    void configure(EndpointRegistrar registrar);

}
Copy to clipboard

@Bean
SqsListenerConfigurer configurer(ObjectMapper objectMapper) {
    return registrar -> registrar.setObjectMapper(objectMapper);
}
Copy to clipboard

@Bean
SqsAsyncClientCustomizer customizer() {
    return builder -> {
        builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
            c.apiCallTimeout(Duration.ofMillis(1500));
        }));
    };
}
Copy to clipboard

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sqs:DeleteMessage",
                "sqs:ReceiveMessage",
                "sqs:SendMessage",
                "sqs:GetQueueAttributes",
                "sqs:GetQueueUrl"
            ],
            "Resource": "yourARN"
        }
Copy to clipboard

<dependency>
    <groupId>io.awspring.cloud</groupId>
    <artifactId>spring-cloud-aws-starter-imds</artifactId>
</dependency>
Copy to clipboard

spring.cloud.aws.imds.enabled=false
Copy to clipboard

import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.imds.Ec2MetadataClient;
import software.amazon.awssdk.imds.Ec2MetadataResponse;

...
@Autowired Ec2MetadataClient client;
client.get("/latest/meta-data/spot/termination-time");
Expand folded textCopy to clipboard

spring.config.import=aws-secretsmanager:/secrets/database-secrets
Copy to clipboard

spring.config.import=optional:aws-secretsmanager:/secrets/database-secrets
Copy to clipboard

spring.config.import=aws-secretsmanager:/secrets/database-secrets;/secrets/webclient-secrets
Copy to clipboard

spring.config.import=aws-secretsmanager:arn:aws:secretsmanager:eu-central-1:0123456789:secret:secrets/database-secrets
Copy to clipboard

spring.config.import[0]=optional:aws-secretsmanager=/secrets/required-secret
spring.config.import[1]=aws-secretsmanager=/secrets/optional-secret
Copy to clipboard

import org.springframework.beans.factory.annotation.Autowired;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.CreateSecretRequest;

...
@Autowired
private SecretsManagerClient secretsManagerClient;
...
secretsManagerClient.createSecret(CreateSecretRequest.builder().name(name).secretString(secret).build());
Expand folded textCopy to clipboard

package com.app;

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;

import org.springframework.boot.BootstrapRegistry;
import org.springframework.boot.BootstrapRegistryInitializer;

public class SecretsManagerBootstrapConfiguration implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        registry.register(SecretsManagerClient.class, context -> {
            AwsCredentialsProvider awsCredentialsProvider = StaticCredentialsProvider.create(AwsBasicCredentials.create("yourAccessKey", "yourSecretKey"));
            return SecretsManagerClient.builder().credentialsProvider(awsCredentialsProvider).region(Region.EU_WEST_2).build();
        });
    }
}
Expand folded textCopy to clipboard

org.springframework.boot.BootstrapRegistryInitializer=com.app.SecretsManagerBootstrapConfiguration
Copy to clipboard

package com.app;

import io.awspring.cloud.autoconfigure.config.secretsmanager.SecretsManagerClientCustomizer;
import java.time.Duration;
import org.springframework.boot.BootstrapRegistry;
import org.springframework.boot.BootstrapRegistryInitializer;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClientBuilder;

class SecretsManagerBootstrapConfiguration implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        registry.register(SecretsManagerClientCustomizer.class, context -> (builder -> {
            builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
                c.apiCallTimeout(Duration.ofMillis(2001));
            }));
        }));
    }
}
Expand folded textCopy to clipboard

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-commons</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-context</artifactId>
</dependency>
Copy to clipboard

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "secretsmanager:GetSecretValue",
            "Resource": "yourArn"
        }
    ]
}
Copy to clipboard

spring.config.import=aws-parameterstore:/config/spring/
Copy to clipboard

spring.config.import=optional:aws-parameterstore:/config/spring/
Copy to clipboard

spring.config.import=aws-parameterstore:/config/spring/;/config/app/
Copy to clipboard

spring.config.import[0]=optional:aws-parameterstore=/config/spring/
spring.config.import[1]=aws-parameterstore=/config/optional-params/
Copy to clipboard

import org.springframework.beans.factory.annotation.Autowired;
import software.amazon.awssdk.services.ssm.SsmClient;

...
@Autowired
private SsmClient ssmClient;
...
ssmClient.getParametersByPath(request -> request.path("/config/spring/")).parameters();
Expand folded textCopy to clipboard

package com.app;

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ssm.SsmClient;

import org.springframework.boot.BootstrapRegistry;
import org.springframework.boot.BootstrapRegistryInitializer;

class ParameterStoreBootstrapConfiguration implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        registry.register(SsmClient.class, context -> {
            AwsCredentialsProvider awsCredentialsProvider = StaticCredentialsProvider.create(AwsBasicCredentials.create("yourAccessKey", "yourSecretKey"));
            return SsmClient.builder().credentialsProvider(awsCredentialsProvider).region(Region.EU_WEST_2).build();
        });
    }
}
Expand folded textCopy to clipboard

org.springframework.boot.BootstrapRegistryInitializer=com.app.ParameterStoreBootstrapConfiguration
Copy to clipboard

package com.app;

import io.awspring.cloud.autoconfigure.config.parameterstore.SsmClientCustomizer;
import java.time.Duration;
import org.springframework.boot.BootstrapRegistry;
import org.springframework.boot.BootstrapRegistryInitializer;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.ssm.SsmClientBuilder;

class ParameterStoreBootstrapConfiguration implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        registry.register(SsmClientCustomizer.class, context -> (builder -> {
            builder.overrideConfiguration(builder.overrideConfiguration().copy(c -> {
                c.apiCallTimeout(Duration.ofMillis(2000));
            }));
        }));
    }
}
Expand folded textCopy to clipboard

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-commons</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-context</artifactId>
</dependency>
Copy to clipboard