A lot of you are likely familiar with Amazon's EC2 cloud service. It's a "platform-as-a-service" solution that allows you to rent, on-demand, virtual machines (VMs). Those VM instances can run a variety of OSs, but the most common are Linux-based distros. Amazon offers a whole variety of VM types, depending upon your need. They range from high-performance VMs, to those sporting a huge amount of RAM.
While the lower-end Amazon instances are very cost-effective, they can still get rather pricey over time. In many cases, you likely don't need them running all-the-time. Using Amazon's EC2 API, you can programmatically manage just about any aspect of the VM, from startup to shutdown.
My son Owen recently has been using an EC2 instance to host some popular games such as Mindcraft. By hosting it himself, he can make modifications to the game logic, and apply other mods (apparently). However, since he's in school during the day, the instance really doesn't need to running all the time.
Given that, I had started to just write some Java routines that leverage the Amazon API to startup or shutdown his EC2 instance. I was then going to use Quartz to provide the scheduling capabilities. This would obviously work fine. However, I figured it might be a whole lot easier to use Apache Camel to manage the lifecycle. In this post, I'll describe how I did that -- here's a link to the
Eclipse project (you don't have to use Eclipse to run the project -- you can just unzip it as well).
Prerequisites
In order to follow this example, I'm pretty much assuming you're pretty familiar with Java and related tools such as Maven and Eclipse. To run the project yourself, you'll need to have Java and Maven installed. While recommended, you really don't need Eclipse if you just want to run everything as-is from the command line.
Also, since we're using this project to start/stop Amazon EC2 instances, I also presume you have an EC2 account setup with an EC2 instance available to use.
To use the example, all you have to do is unzip the project into a folder of your choice. If you have Eclipse configured with the Maven plugin, you can simply import it -- within Eclipse choose
File->Import->Existing Projects into Workspace. Then, choose the option
Select Archive File, and select the
zip file.
Quick Intro to Camel
While this article isn't intended as a introduction to Camel (I will actually have a future post on this), a brief intro is necessary. Camel can be described as a messaging orchestration and routing product. It shares many similar characteristics to a conventional ESB, insofar as it contains a wealth of different protocol adapters. However, it's a lot lighter-weight than an ESB, and doesn't have it's own container in which it runs. As with most ESBs, you can also add your own components to extend the out-of-the-box functionality.
There are two mains ways in which you can configure Camel. Once is using the Java DSL, and the other is the XML-based Spring DSL. We're going to use the Spring approach for this project, since that's the one I generally prefer (is also a lot easier to learn if you don't know Java).
Here's a simple example of a configuration that produces the customary "Hello World" output to the console:
<beans xmlns="http://www.springframework.org/schema/beans"
// namespaces not shown >
<camel:camelContext xmlns="http://camel.apache.org/schema/spring">
<!-- this route will run a remote request against an ec2 instance -->
<camel:route>
<camel:from
uri="timer://myTimer?fixedRate=true&period=10&repeatCount=1"/>
<camel:setBody>
<camel:constant>Hello World!</camel:constant>
</camel:setBody>
<camel:to uri="stream:out"/>
</camel:route>
</camel:camelContext>
</beans>
For those of you who know Spring, the above should seem pretty familiar. The top-level element is the typical beans element, which has associated with it a bunch of namespace definitions (not shown, but this simple example can be found in the
camel-spring-hello-world.xml file in the project). The most relavent part for our discussion starts with the
camel:route element. That's where we define the route that the message will traverse. The message is initiated using the
camel:from element's
@uri definition. In this case, we're using the Camel
Timer component (there are something like 80 components in Camel). The part which follows the
timer: defines the frequency by which a message will be initiated (kicked-off). In this case, it will start generating messages every 10 milliseconds following startup based upon the setting in the
@period element. However, because
@repeatCount is set to 1, it will only generate a single message.
Most of the time, the
camel:from element is used poll or periodically call a remote service such as an FTP site (for periodically scanning for files) or some HTTP service. In this case, only an empty message is being generated. So, the next statement in the route defines a message body. In this case, it's the proverbial "Hello World!". That is done using the
camel:setBody element. Since we're assigning it a static value, we use child node
camel:constant to set the static value (values can also be set more dynamically using expressions, which we'll see later).
Lastly, we're using the
stream component to output the results (will print "Hello World!") to the command line. If you want to run this very simple demo, edit the
pom.xml file located at the root directory so that the configuration element within the
project/build/plugins/plugin element for the
org.apache.camel resembles:
META-INF/spring/camel-spring-hello-world.xml
Then, run at the command line, enter mvn camel:run. This will launch camel in an embedded type fashion and run the route.
Moving on to the EC2 Example
With that basic overview in mind, let's dive into the real problem we are trying to solve -- using Camel to schedule the starting and stopping of an Amazon EC2 instance.
Camel comes out-of-the-box with some existing integrations to Amazon's web services. However, there isn't one specifically for EC2. However, Amazon does have a Java API that makes it pretty straightforward to use. We'll just need to write a little Camel component using that to satisfy our needs.
In Camel, there are a few different ways you can extend it's functionality. We'll demonstrate one of the easiest -- just using a plain old Java object (POJOs). I'm calling the Java bean EC2Controller. We will define 3 methods -- one method for starting the EC2 instance (startInstance), one for stopping the EC2 instance (stopInstance), and one general purpose method for just setting up the necessary communication configuration (setup).
Let's start with the setup method:
private void setup() throws Exception {
try {
credentials =
new PropertiesCredentials(EC2Controller.class.getResourceAsStream(
"../../../AwsCredentials.properties"));
} catch (IOException e1) {
System.out.println("Credentials were not properly entered into" +
" AwsCredentials.properties.");
System.out.println(e1.getMessage());
throw new Exception (e1.getMessage());
}
}
Not really much happening here - - just trying to load in the AWS credentials which must be present in the file referenced above (NOTE: you will need to update this file with your own AWS credential settings).
The startInstance method isn't terrible complicated either. Time doesn't permit me to go through what each of the Amazon API calls is doing, but I think you'll see it's pretty easy to follow-along (I've added some annotations to the code).
public void startInstance(@Body String body, Exchange exchange) throws Exception {
Log.debug("Entering EC2Controller.startInstance(). " +
"Processing Ec2 Instance: " + body);
// covered this above
setup();
// Create the AmazonEC2Client object so we can call various APIs.
// The credentials class variable gets populated in the setup method.
AmazonEC2 ec2 = new AmazonEC2Client(credentials);
// We'll use this EC2 object to determine whether the EC2 instance is already
// running
DescribeInstanceStatusRequest statusRequest
= new DescribeInstanceStatusRequest();
ArrayList instances = new ArrayList();
// The message body, passed by camel, will contain the EC2 instance we
// are working with
instances.add(body);
statusRequest.setInstanceIds(instances);
Log.debug("Checking server status");
// This will actually run the request now wrapping Amazon's web services
DescribeInstanceStatusResult result =
(ec2.describeInstanceStatus(statusRequest));
// If the result contains a status, that means it's already running.
// Otherwise, start it
if (result.getInstanceStatuses().size() > 0) {
exchange.getOut().setBody("Camel Start Instance Status: " +
"Instance already running...not started");
} else {
Log.debug("Starting ec2 instance: " + body);
// This EC2 object is used to start an EC2 instance.
StartInstancesRequest startRequest = new StartInstancesRequest(instances);
// Sends the web services command to Amazon AWS
ec2.startInstances(startRequest);
// this new message in the body will be sent via email
exchange.getOut().setBody("Camel Start Instance Status: Ec2 Instance " +
body + " started");
}
}
I think for the most part, the code is pretty self-explanatory, if you are already familiar with Amazon's EC2 concepts. As you will see in a moment, we pass the Amazon EC2 instance Id in the Camel message body. The method parameter annotation,
@Body, is a Camel annotation, and based upon that, Camel will automatically try and pass the appropriate object based upon the annotation used (
Exchange is also passed automatically by Camel -- since that's a native Camel object, it doesn't require the annotation).
With the EC2 instance id at hand, we then populate that into an
ArrayList. This is required because the Amazon EC2 API calls often require a list since the calls can support performing activities on multiple instances at once. We use the Amazon API's to determine whether the instance in question is already running, and if not, we use the
StartInstanceRequest to fire it up.
The
stopInstance method is actually very similar, but we instead use the
StopInstanceRequest Amazon API call to stop the running instance. Pretty easy, huh?
Now that we've got our custom Java bean written to interface with Amazon, let's wire it all up in Camel.
Camel Setup/Configuration
Before we delve into the route configuration, which is where all the fun resides, let's first look at some of the initial setup within the
camelContext element (we're working with the
camel-context.xml file here, located under
src/main/resource/META-INF/spring subdirectory.). This is where you can specify property files that need to be referenced, exception handling logic, and, as a convenience, your endpoint URIs. Here's what we have:
<camel:camelContext xmlns="http://camel.apache.org/schema/spring">
<camel:propertyPlaceholder id="props" location="zazarie.camel.properties" />
<!-- define quartz endpoints -->
<camel:endpoint id="Quartz.Start" uri="quartz://startEc2?cron=0+0+08+*+*+?"/>
<camel:endpoint id="Quartz.Stop" uri="quartz://stopEc2?cron=0+0+20+*+*+?"/>
<camel:endpoint id="RunOnce" uri="timer://myTimer?fixedRate=true&period=10&repeatCount=1"/> <!-- for testing -->
<camel:onException>
<camel:exception>java.lang.Exception</camel:exception>
<camel:handled>
<camel:constant>true</camel:constant>
</camel:handled>
<camel:setBody>
<camel:simple>${properties:SMTP.FAILED}</camel:simple>
</camel:setBody>
<camel:to uri="seda:SendStatusEmail"/>
</camel:onException>
The first thing we do is define a location for a property file. As we'll see below, this is simply used to avoid some hard-coding of values in the Camel configuration (some is unfortunately required). This is done using the
camel:PropertyPlaceholder element, which specifies a location of a properties file in the classpath. The next thing we do is define some endpoints. The first two represent Quartz component endpoints that define schedules for starting and stopping the instances. The Camel Quartz configuration has the details on how to interpret the configuration strings, but suffice it to say that the
Quartz.Start will kick off a message at 8am, and
Quartz.Stop will do the same at 8pm. While we could include these directly within the
@uri attribute of the
camel:from element, centralizing the endpoints makes maintenance a bit more straightforward with it done in this fashion (although I'm a bit loose when following that pattern myself, as you likely have noticed).
Camel actually comes with two scheduling type services/components, and we've actually seen both of them here. The
Timer component, which we use for defining the endpoint called
RunOnce, is pretty bare-bones in functionality (this endpoint is used for testing only -- handy for kicking off a message right after Camel starts without having to twiddle with the cron settings used in the Quartz endpoints). If you need more advanced scheduling capabilities, the
Quartz component is the way to go (gives you functionality like Unix/Linux cron).
As for the exception handling, all we're basically doing here is trapping for any exceptions that occur when the process is run, with an email ultimately being sent (very basic error handling, to be sure) in the event of an exception. We'll talk a little about the route we use for sending the email (the
seda:SendStatusEmail uri).
Now that we have the basic housekeeping stuff in place, let's look at the route configuration.
Camel Route Configuration for Starting an EC2 Instance
We'll actually define two main routes -- one for starting up the EC2 instance, and the other for shutting it down. They are both very simple -- a
Quartz component will fire off a message at the preordained time, which will then kickoff the Java bean we created for interfacing with Amazon. Finally, we'll send an email out with the status update.
Let's look at the startup route first:
<camel:route>
<camel:from uri="ref:Quartz.Start" />
<camel:setBody>
<camel:simple>${properties:EC2.INSTANCE1}</camel:simple>
</camel:setBody>
<camel:bean ref="Controller" method="startInstance"/>
<camel:to uri="seda:SendStatusEmail"/>
<camel:to uri="stream:out" />
</camel:route>
The
camel:from element, which defines how the message will be trigged in the route, references the
Quartz.Start endpoint we defined a bit above. When that endpoint fires the message, we then set the Camel message body to equal the value associated with the property
EC2.INSTANCE (as you recall, the property file was loaded using the
propertyPlaceholder statement). In other words, we're setting the Camel message body to be the Amazon EC2 instance Id we want to start. Then, the bean identified as
Controller is called. This invokes the EC2Controller Java bean we created earlier that interfaces with Amazon's AWS. This
bean is configured in the beans element of this same XML file as:
<bean id="Controller" name="Controller" class="zazarie.camel.beans.EC2Controller" />
Lastly, we make that curious called to
seda:SendStatusEmail. This is actually another defined endpoint, and it's used for sending out the emails. Why do this? For one, it allows us to easily re-use that endpoint, since we that functionality in a few places. Why the
seda protocol? That is an asynchronous protocol used by Camel, which is perfect for this, because it's really just a fire-and-forget piece of functionality (i,.e,. sending the email).
Here's how we define that
seda endpoint:
<camel:route>
<camel:from uri="seda:SendStatusEmail"/>
<camel:setHeader headerName="to">
<camel:simple>${properties:SMTP.SENDTO}</camel:simple>
</camel:setHeader>
<camel:setHeader headerName="subject">
<camel:simple>${properties:SMTP.SUBJECT}</camel:simple>
</camel:setHeader>
<camel:to uri="smtps://smtp.gmail.com?&username=someuser@gmail.com&password=password-here&contentType=text/plain"/>
</camel:route>
So, when you saw the statement earlier:
<camel:to uri="seda:SendStatusEmail"/>
This was invoking this route. This route first sets the
to and
subject headers using properties from the property file, and then calls the
smtps (
Mail component) protocol to send the outbound message. For some reason, Camel doesn't seem to allow certain of the properties, such as
username and
password, to be set using the
camel:setHeader mechanism (which is a minor bummer).
We've now covered how the route works that starts the Amazon EC2 instance, let's look at the one use for stopping it -- it's pretty much identical.
Camel Route Configuration for Starting an EC2 Instance
The route used to stop the EC2 instance is actually identical, with one minor change -- we invoke the stopInstance method of the Controller bean:
<camel:bean ref="Controller" method="stopInstance"/>
Setup and Run
After you've extracted the project into some directory location, you will need to do a few things to get it ready for your environment.
- Edit the zazarie.camel.properties file. You will want to enter in your own email address where you want the status messages sent, and change the EC2 instance Id to the one you want to manage.
- In the camel.context file, you will want to edit the smtps URI so that it contains the SMTP server you are using to send the outbound status message.
- Edit the AwsCredentials.properties file to use your own Amazon EC2 security credentials.
- To setup it up for testing, use the RunOnce endpoint in lieu of the Quartz.Start or Quartz.Stop @ref's in the routes used for starting and stopping EC2.
Finally, we are ready to run it using mvn camel:run.
Additional Functionality
In the
camel-context.xml file, I also included an additional route that demonstrates how you can run some remote commands on an an EC2 instance. This is the commented out route that uses the
exec Camel component. One of the common requirements before starting or stoping an EC2 instance is to run some system commands. This might be to cleanly shutdown a database, or issue some command to start a service upon startup. I had attempted to use Camel's built-in SSH component, but never could get it working correctly. However, it's pretty easy to just invoke a .bat (Windows) or .sh (Linux) script that uses something like command line SSH or Putty to invoke a remote command. The
Mina component could also be used for this purpose (it's very slick), but I didn't have time to fully explore that.
Other areas that this example could be enhanced would be to demonstrate how Camel could be used to periodically poll an EC2 instance for load/usage. Then, if the load exceeds a certain high-water mark, Camel could kick off instantiating a new EC2 instance.
Once thing that I haven't had a chance to tackle yet is how to run this routine under a Tomcat container. Having to run it through through the command line is good for testing, but not for a production environment, you likely want to configure it as a war file. That's not hard to do -- maybe I'll add a note on that in the near future if folks are interested.
Let me know your feedback!
jeff davis, Monument Co
References --
Project Source Code.
