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

== Spring Boot Auto-Configuration

When using aws2-lambda 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-lambda-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 17 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.component.aws2-lambda.access-key* | Amazon AWS Access Key |  | String
| *camel.component.aws2-lambda.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-lambda.aws-lambda-client* | To use a existing configured AwsLambdaClient as client. The option is a software.amazon.awssdk.services.lambda.LambdaClient type. |  | LambdaClient
| *camel.component.aws2-lambda.configuration* | Component configuration. The option is a org.apache.camel.component.aws2.lambda.Lambda2Configuration type. |  | Lambda2Configuration
| *camel.component.aws2-lambda.enabled* | Whether to enable auto configuration of the aws2-lambda component. This is enabled by default. |  | Boolean
| *camel.component.aws2-lambda.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-lambda.operation* | The operation to perform. It can be listFunctions, getFunction, createFunction, deleteFunction or invokeFunction |  | Lambda2Operations
| *camel.component.aws2-lambda.override-endpoint* | Set the need for overidding the endpoint. This option needs to be used in combination with uriEndpointOverride option | false | Boolean
| *camel.component.aws2-lambda.pojo-request* | If we want to use a POJO request as body or not | false | Boolean
| *camel.component.aws2-lambda.proxy-host* | To define a proxy host when instantiating the Lambda client |  | String
| *camel.component.aws2-lambda.proxy-port* | To define a proxy port when instantiating the Lambda client |  | Integer
| *camel.component.aws2-lambda.proxy-protocol* | To define a proxy protocol when instantiating the Lambda client |  | Protocol
| *camel.component.aws2-lambda.region* | The region in which Lambda 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-lambda.secret-key* | Amazon AWS Secret Key |  | String
| *camel.component.aws2-lambda.trust-all-certificates* | If we want to trust all certificates in case of overriding the endpoint | false | Boolean
| *camel.component.aws2-lambda.uri-endpoint-override* | Set the overriding uri endpoint. This option needs to be used in combination with overrideEndpoint option |  | String
| *camel.component.aws2-lambda.use-default-credentials-provider* | Set whether the Lambda client should expect to load credentials through a default credentials provider or to expect static credentials to be passed in. | false | Boolean
|===
// spring-boot-auto-configure options: END
