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

== Spring Boot Auto-Configuration

When using aws2-ec2 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-ec2-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-ec2.access-key* | Amazon AWS Access Key |  | String
| *camel.component.aws2-ec2.amazon-ec2-client* | To use a existing configured AmazonEC2Client as client. The option is a software.amazon.awssdk.services.ec2.Ec2Client type. |  | Ec2Client
| *camel.component.aws2-ec2.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-ec2.configuration* | The component configuration. The option is a org.apache.camel.component.aws2.ec2.AWS2EC2Configuration type. |  | AWS2EC2Configuration
| *camel.component.aws2-ec2.enabled* | Whether to enable auto configuration of the aws2-ec2 component. This is enabled by default. |  | Boolean
| *camel.component.aws2-ec2.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-ec2.operation* | The operation to perform. It can be createAndRunInstances, startInstances, stopInstances, terminateInstances, describeInstances, describeInstancesStatus, rebootInstances, monitorInstances, unmonitorInstances, createTags or deleteTags |  | AWS2EC2Operations
| *camel.component.aws2-ec2.pojo-request* | If we want to use a POJO request as body or not | false | Boolean
| *camel.component.aws2-ec2.proxy-host* | To define a proxy host when instantiating the EC2 client |  | String
| *camel.component.aws2-ec2.proxy-port* | To define a proxy port when instantiating the EC2 client |  | Integer
| *camel.component.aws2-ec2.proxy-protocol* | To define a proxy protocol when instantiating the EC2 client |  | Protocol
| *camel.component.aws2-ec2.region* | The region in which EC2 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-ec2.secret-key* | Amazon AWS Secret Key |  | String
| *camel.component.aws2-ec2.trust-all-certificates* | If we want to trust all certificates in case of overriding the endpoint | false | Boolean
|===
// spring-boot-auto-configure options: END
