Resin Cloud deployment with Amazon Roo
From Resin 4.0 Wiki
(Updating to 4.0.27 in progress...)
Older version that uses Roo to generate an application.
This tutorial is going to cover the basics of using the Resin Java application server with Amazon Web Services for cloud deployment. If you are new to cloud computing and IaaS (Infrastructure as a Service), follow along and you will soon be deploying Java web applications in the cloud. You wil create an EC2 instance. You will download and install Resin on Ubuntu on a local machine. You will install Resin on an Amazon Linux AMI instance (EC2 instance). You will use Roo to create a simple application and deploy it.
We use Roo because Spring is fairly widely used, and Roo is a quick way to generate a sample app. Future tutorials will use other common Java tools as well as show you how to configure and manage a complete Resin server cluster. Think of this as the first tutorial in a series of tutorials.
For this tutorial you will need Resin 4.0.27 or later. Check back periodically because as we are going to expand the tutorial and improve Resin's support of cloud deployments. The Resin engineering team plans on improving cloud support continuously.
Many of the steps in this tutorial would be similar even if you were using Eucalyptus, CloudStack with CloudBridge, RightScale myCloud or even OpenNebula this guide should help you along as they all support the Amazon EC2 REST APIs. Also any cloud computing environment (private or public, on premises or hosted) will have similar characteristics. Thus even if you are using a private cloud using OpenStack like Project Olympus, the principles will be the same. In fact even using remote servers deployed in a datacenter or virtualized servers with Xen Server, Xen Cloud or VMWare vSphere the steps will be very similar.
For this tutorial we expect you are familiar with starting, and stopping Amazon WS instances. If you are not, go through this tutorial from Amazon WS. You will need an Amazon WS account. Amazon WS allows you to have free tier so you can learn Amazon WS (EC2, S3, Elastic Load Balancer, Block Storage, SimpleDB, Simple Queue Service, Simple Notification Service).
This tutorial will show how to install Resin and manage on CentOS/Amazon Linux/Red Hat Enterprise Linux as well as Ubuntu/Debian. The local development box for this tutorial is Ubuntu/Debian. The instance running in the cloud is Amazon Linux which is a fork of CentOS which is a clone of Red Hat Enterprise Linux. Thus even if you are not interested in Amazon cloud deployment, you might find this tutorial a good intro to Resin install and app deployment.
Fire up an Amazon Instance
Fire up an Amazon Instance using Amazon Linux (basically CentOS 5.4). Then install Resin as follows using RPM:
$ sudo rpm --import http://caucho.com/download/rpm/RPM-GPG-KEY-caucho
$ sudo yum install http://caucho.com/download/rpm/4.0.24/x86_64/resin-pro-4.0.26-1.x86_64.rpm
If the above steps confuses you, make sure you go through the Amazon EC2 tutorial and then return to this step (tutorial from Amazon WS).
If everything went well, then Resin should be installed. You can test this as follows:
$ resinctl status
Output
Resin/4.0.27 status for watchdog at 127.0.0.1:6600 watchdog: watchdog-pid: 1455 server 'app-0' : ACTIVE password: missing watchdog-user: root user: resin(resin) root: /var/www conf: /etc/resin/resin.xml pid: 1570 uptime: 0 days 00h04
Install Resin on a Local Box
Install Resin locally so you test locally and deploy. Feel free to install it on any supported OS.
Add Caucho's Debian repository to your system's repositories to use automated update tools like Synaptic and apt-get. To do this, add the following line to your /etc/apt/sources.list
deb http://caucho.com/download/debian unstable multiverse
Then install Resin as follows:
$ sudo apt-get update
$ sudo apt-get install resin-pro
It is a good idea to make sure the version you install on Amazon AMI matches the version you install locally.
You can see that Resin is installed as follows:
$ ls /etc/resin
app-default.xml health.xml resin.properties
cluster-default.xml resin-inf resin.xml
$ ls /var/www
doc licenses log resin-data watchdog-data webapps
$ ls /etc/init.d/resin
/etc/init.d/resin
$ ls -l /usr/local/share/resin
lrwxrwxrwx 1 root root 16 2012-03-22 18:42 /usr/local/share/resin -> resin-pro-4.0.27
Also at this point, Resin should be running as well, and you can verify this with resinctl status:
$ resinctl status
Output
Resin/4.0.27 status for watchdog at 127.0.0.1:6600 watchdog: watchdog-pid: 18597 server 'app-0' : ACTIVE password: missing watchdog-user: root user: www-data(www-data) root: /var/www conf: /etc/resin/resin.xml pid: 18692 uptime: 0 days 00h13
Install Maven 3 (Optional, for Roo example)
If you already have a test .war file, you can skip to the deploy section and deploy your own war.
Install maven. Maven is not in the public Ubuntu repository.
$ sudo add-apt-repository "deb http://build.discursive.com/apt/ lucid main"
$ sudo apt-get update
$ sudo apt-get install maven
Create a symbolic link:
$ sudo ln -s /usr/local/maven/bin/mvn /usr/local/bin/mvn
Install Spring Roo (Optional)
If you already have a test .war file, you can skip to the deploy section and deploy your own war.
Download and install Spring Roo using directions at the Spring Roo site.
This is how I install roo:
$ unzip spring-roo-1.2.0.RC1.zip
$ sudo mv spring-roo-1.2.0.RC1 /usr/local/share/
$ sudo ln -s /usr/local/share/spring-roo-1.2.0.RC1/ /usr/local/share/spring-roo
$ sudo ln -s /usr/local/share/spring-roo/bin/roo.sh /usr/bin/roo
At the roo prompt, type hint.
$ roo
____ ____ ____
/ __ \/ __ \/ __ \
/ /_/ / / / / / / /
/ _, _/ /_/ / /_/ /
/_/ |_|\____/\____/ 1.2.0.RC1 [rev dcaa483]
Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.
...
roo> hint
..
Hint should always let you know what you might want to do next. Please feel free to read the Roo docs for details or just follow along and read the Roo docs later.
Create the project, this generates maven project files and Spring starter project.
roo> project --topLevelPackage com.example.blog
Created ROOT/pom.xml
Created SRC_MAIN_RESOURCES
Created SRC_MAIN_RESOURCES/log4j.properties
Created SPRING_CONFIG_ROOT
Created SPRING_CONFIG_ROOT/applicationContext.xml
Next setup the database and JPA, keep it simple to minimize the amount of things we need to configure later.
roo> jpa setup --database H2_IN_MEMORY --provider HIBERNATE
Created SPRING_CONFIG_ROOT/database.properties
Updated SPRING_CONFIG_ROOT/applicationContext.xml
Created SRC_MAIN_RESOURCES/META-INF/persistence.xml
Updated ROOT/pom.xml [added dependencies com.h2database:h2:1.3.161, org.hibernate:hibernate-core:3.6.8.Final, ...]
Create a entity class called blog.
roo> entity jpa --class ~.domain.Blog
Created SRC_MAIN_JAVA/com/example/blog/domain
Created SRC_MAIN_JAVA/com/example/blog/domain/Blog.java
Created SRC_MAIN_JAVA/com/example/blog/domain/Blog_Roo_Configurable.aj
Created SRC_MAIN_JAVA/com/example/blog/domain/Blog_Roo_Jpa_ActiveRecord.aj
Created SRC_MAIN_JAVA/com/example/blog/domain/Blog_Roo_ToString.aj
Created SRC_MAIN_JAVA/com/example/blog/domain/Blog_Roo_Jpa_Entity.aj
Add two fields to the Blog class.
~.domain.Blog roo> field string --fieldName title
Updated SRC_MAIN_JAVA/com/example/blog/domain/Blog.java
Created SRC_MAIN_JAVA/com/example/blog/domain/Blog_Roo_JavaBean.aj
~.domain.Blog roo> field string --fieldName message
Updated SRC_MAIN_JAVA/com/example/blog/domain/Blog.java
Updated SRC_MAIN_JAVA/com/example/blog/domain/Blog_Roo_JavaBean.aj
Create the web tier
~.domain.Blog roo> web mvc setup
Created ROOT/src/main/webapp/WEB-INF/spring
Created ROOT/src/main/webapp/WEB-INF/spring/webmvc-config.xml
Created ROOT/src/main/webapp/WEB-INF/web.xml
...
Updated ROOT/src/main/webapp/WEB-INF/web.xml
Updated ROOT/pom.xml [added dependencies org.springframework:spring-webmvc:${spring.version}, ...]
Updated SRC_MAIN_WEBAPP/WEB-INF/views/footer.jspx
Generate the web tier.
~.domain.Blog roo> web mvc all --package ~.web
Created SRC_MAIN_JAVA/com/example/blog/web
Created SRC_MAIN_JAVA/com/example/blog/web/BlogController.java
...
Created SRC_MAIN_WEBAPP/WEB-INF/views/blogs
Created SRC_MAIN_WEBAPP/WEB-INF/views/blogs/views.xml
Updated SRC_MAIN_WEBAPP/WEB-INF/views/blogs/views.xml
...
Updated SRC_MAIN_WEBAPP/WEB-INF/views/blogs/views.xml
...
Created SRC_MAIN_WEBAPP/WEB-INF/views/blogs/update.jspx
Package our web app
roo> perform package
Exit roo.
roo> exit
Deploy locally and test
Deploy the example Roo app with Resin.
$ resinctl deploy --name blog target/blog-0.1.0.BUILD-SNAPSHOT.war
Deployed production/webapp/default/blog from target/blog-0.1.0.BUILD-SNAPSHOT.war to hmux://127.0.0.1:6800
You can see if the app was actually deployed:
$ resinctl deploy-list
production/webapp/default/blog
Now you should be able to load the Roo blog example.
Create an Elastic IP and assign it to your Amazon WS Linux instance
Background on Elastic IP Amazon EC2 instances are assigned two IP addresses at launch: a private (RFC 1918) address and a public address. The public address is mapped to the private IP address through Network Address Translation (NAT). Every time you start or restart an instance, it gets new public and private addresses.
Amazon EC2 provides a service called Elastic IP addresses. Elastic IP addresses are static IP addresses. Elastic IP addresses are associated with your account, not a specific instances. You can associate an Elastic IP address with an instance. It is good to associate your instance with an IP address so you can direct your calls to that instance when deploying an application.
If you are not familiar with Elastic IPs, read the Amazon documentation on Elastic IP Elastic IP, just scroll down a bit and you can see how to create an Elastic IP from the Amazon WS Web Console.
Directions
Create an Elastic IP and assign it to the Amazon WS Linux instance using the Amazon web console.
I got this IP address.
23.21.195.83
In order to use it, you must assign it to our instance that has Resin. In the console for managing Elastic IP address is an option under actions to assign the Elastic IP address to our instance.
Warning
Remember after you restart the server, you need to reassign it
the Amazon Elastic IP. This means go to the console. Find the list of
Elastic IPs. Select the one you want. Click the Associate Address
button and pick the instance ID of the server that has Resin.
Every time an instance restarts it forgets its IP address unless you reassign it.
Create password for your Amazon Cloud instance
$ resinctl generate-password -user admin -password roofoo
Output
admin_user : admin
admin_password : {SSHA}cgZwV7lyEK3m5JJNv3IzMO0GlqNmzk3J
Create a properties file and put it into user-data of Amazon AMI
Create a file that looks like this:
https : 8443
admin_user : admin
admin_password : {SSHA}2fGGuMzKVkeR2z03J/hoVFqOHWNTw999
web_admin_enable : true
remote_cli_enable : true
web_admin_external : true
web_admin_ssl : true
To put the above in the user-data of that instance, you typically need
to stop the instance from the console or command line. Then from the
Amazon Management Console, select the instance in the instances list,
then select the action "View/Change User Data" and add the contents
above. In a later lesson, we show you how to do this from the command
line.
Reminder Associate with Elastic IP after restarting instance Remember after you restart the server, you need to reassign it the Amazon Elastic IP. This means go to the console. Find the list of Elastic IPs. Select the one you want. Click the Associate Address button and pick the instance ID of the server that has Resin.
After you restart the Amazon instance, look at its security group and make sure the following inbound ports are open up.
It should have the following
Port (Scheme) Source
| 22 (SSH) | 0.0.0.0/0 |
| 80 (HTTP) | 0.0.0.0/0 |
| 443 (HTTPS) | 0.0.0.0/0 |
| 8080 (HTTP*) | 0.0.0.0/0 |
| 8443 (HTTPS*) | 0.0.0.0/0 |
Create ec2.xml file
With Resin 4.0.27 and above you can configure additional config files like mycustom.xml and drop them under /etc/resin/app-inf/mycustom.xml, and these XML files get picked up by Resin and become part of the Resin configuration. This was added to make configuration simpler for cloud deployments.
Background
The actual directive that looks for these additional xml files is in /etc/resin/cluster-default.xml which gets included by /etc/resin/resin.xml.
/etc/resin/cluster-default.xml
...
<resin:import fileset="${__DIR__}/${cluster.id}-inf/**/*.xml"/>
...
The main configuration file for Resin is /etc/resin/resin.xml defines a cluster called 'app'.
/etc/resin/resin.xml
...
<cluster id="app">
...
The above is why you can define xml files into /etc/resin/app/ and they get picked up by Resin.
Directions
Create the file that is listed below called ec2.xml and put it into /etc/resin/app-inf/ec2.xml on the Amazon instance.
<resin xmlns="http://caucho.com/ns/resin"
xmlns:resin="urn:java:com.caucho.resin">
<resin:properties path="http://169.254.169.254/latest/user-data"
optional="true" recover="true"/>
</resin>
The IP address (http://169.254.169.254) is a meta address that Xen, and Amazon EC2 use to configure per instance data about the instance you are running. The above is configured to read properties out of this user data location.
Log into Amazon AMI instance and add the above to /etc/resin/app-inf/ec2.xml.
$ ssh -i resin2.pem ec2-user@23.21.195.83 $ sudo mkdir /etc/resin/app-inf $ sudo nano /etc/resin/app-inf/ec2.xml
XML files that you add to /etc/resin/app-inf/ get added to the resin app cluster configuration configuration. This allows you add just the additional config you need without changing the rest on the resin configuration.
Remember: the Amazon security group that this instance needs has to open up the following ports 8080, and 8443, 80, and 443.
To test out our changes, from your local development machine execute this command:
$ resinctl deploy --name blog --address 23.21.195.83 --port 8080 --user
admin --password roofoo target/blog-0.1.0.BUILD-SNAPSHOT.war
You can see if the deploy worked by do the following:
$ resinctl deploy-list --address 23.21.195.83 --port 8080 --user admin --password roofoo production/webapp/default/blog
Now it works in the cloud:
http://23.21.195.83:8080/blog/
Next step learn how to spin up instances with eucatools Resin Cloud deployment with Amazon WS EC2 and Euca Tools.
Next step learn how to use MySQL setup with Resin and Amazon RDS Java EE Setup, JDBC datasource, JNDI, MySQL and MySQL setup with Amazon RDS/EC2.
Resin Cloud Deployment Reference
NOTES and prototyping
$ mkdir test rick@ubuntu:~$ cd test rick@ubuntu:~/test$ touch foo.xml rick@ubuntu:~/test$ cd .. rick@ubuntu:~$ resinctl config-deploy foo.xml com.caucho.config.ConfigException: Deploy expects to be used with a *.jar file or directory at foo.xml rick@ubuntu:~$ resinctl config-deploy test Deployed production/config/resin from test to hmux://127.0.0.1:6800
$ resinctl config-ls foo.xml
$ ls /var/www/resin-data/app-0/config/ foo.xml
In resin.xml you have the following entries:
<resin:import fileset="cloud:/resin-inf/*.xml" recover="true"/> <resin:properties path="cloud:/resin.properties"
optional="true" recover="true"/>
I think
/var/www/resin-data/app-0/config
might refer to cloud:/
Not sure.
cluster-default refers to
these to laod jars....
<tree-loader path="cloud:/{cluster.id}-inf"/> <resin:import fileset="cloud:/${cluster.id}-inf/**/*.xml"
recover="true"/>
I know from the test
./server/22f0.qa
That cloud:/ does in fact refer to /var/www/resin-data/app-0/config. I think.
Thus when you deploy to a particular server, you are in fact deploying to that servers cloud:/
