// spring-boot-auto-configure options: START
:page-partial:
:doctitle: Camel Spring Boot Starter for aws2-kms

== Spring Boot Auto-Configuration

When using aws2-kms with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-aws2-kms-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 14 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.component.aws2-kms.access-key* | Amazon AWS Access Key |  | String
| *camel.component.aws2-kms.autowired-enabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | Boolean
| *camel.component.aws2-kms.configuration* | Component configuration. The option is a org.apache.camel.component.aws2.kms.KMS2Configuration type. |  | KMS2Configuration
| *camel.component.aws2-kms.enabled* | Whether to enable auto configuration of the aws2-kms component. This is enabled by default. |  | Boolean
| *camel.component.aws2-kms.kms-client* | To use a existing configured AWS KMS as client. The option is a software.amazon.awssdk.services.kms.KmsClient type. |  | KmsClient
| *camel.component.aws2-kms.lazy-start-producer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | Boolean
| *camel.component.aws2-kms.operation* | The operation to perform |  | KMS2Operations
| *camel.component.aws2-kms.pojo-request* | If we want to use a POJO request as body or not | false | Boolean
| *camel.component.aws2-kms.proxy-host* | To define a proxy host when instantiating the KMS client |  | String
| *camel.component.aws2-kms.proxy-port* | To define a proxy port when instantiating the KMS client |  | Integer
| *camel.component.aws2-kms.proxy-protocol* | To define a proxy protocol when instantiating the KMS client |  | Protocol
| *camel.component.aws2-kms.region* | The region in which EKS client needs to work. When using this parameter, the configuration will expect the lowercase name of the region (for example ap-east-1) You'll need to use the name Region.EU_WEST_1.id() |  | String
| *camel.component.aws2-kms.secret-key* | Amazon AWS Secret Key |  | String
| *camel.component.aws2-kms.trust-all-certificates* | If we want to trust all certificates in case of overriding the endpoint | false | Boolean
|===
// spring-boot-auto-configure options: END
