Resin as a PaaS: Amazon RDS/EC2 Web App Deployment with MySQL JDBC database

[IN PROGRESS BEING UPGRADED to 4.0.28]

This is a continuance of our earlier tutorial on Resin cloud deploy on Amazon EC2. The first part of this tutorial could be used to see how to configure Resin for production deployments. We create a simple web application that uses MySQL.

The first part of this tutorial just shows how to use a database from JNDI. It shows how to install the JDBC jar files and how to configure Resin datasources. There is nothing cloud centric per se about the first part. It also shows how to do remote configuration of Resin servers.

Then we show you how to setup Amazon RDS for MySQL. Then configure Resin to talk to the RDS MySQL instance.

These tutorials are related:

Part 1 Resin_Cloud_deployment_with_Amazon

Part 2 Resin_Cloud_deployment_with_Amazon_WS_EC2_and_Euca_Tools

Tutorial Status

This tutorial is in progress. It is being updated from 4.0.24/4.0.26 to 4.0.27 and 4.0.28. Improvements were made to Resin to support remote cloud deployment and configuration.

We assume your development box is Ubuntu or Debian and your Amazon AMI is Amazon Linux (CentOS 4.5 more or less/Red Hat Enterprise).

Install MySQL on local box

First let's install MySQL create a user called bloguser with a password. Then let's create a database called blogdb.

$ sudo apt-get install mysql-server

Startup MySQL client tool to create a new user and database:

$ mysql -u root -p

Next create a user called bloguser with the pass roofoo.

mysql> GRANT ALL PRIVILEGES ON *.* TO 'bloguser'@'%' IDENTIFIED BY 'roofoo' WITH GRANT OPTION;

Output:
Query OK, 0 rows affected (0.00 sec)

Next create a database called blogdb.

mysql> create database blogdb;

Output:
Query OK, 1 row affected (0.00 sec)

Use blogdb database and create a table called blog.

mysql> use blogdb;

Output:
Database changed

Create a table called blog.

mysql> CREATE TABLE blog (id INT NOT NULL PRIMARY KEY AUTO_INCREMENT, 
                                            title VARCHAR(80), message VARCHAR(2000));

Output:
Query OK, 0 rows affected (0.01 sec)

Exit the MySQL client.

mysql> exit;

Output:
Bye

Local Dev Box: Make sure Resin is started

Check the status, if status cannot connect then Resin is not started:

$ resinctl status
Resin/4.0.27 can't retrieve status of -server 'app-0' for watchdog at 127.0.0.1:6600.
com.caucho.bam.RemoteConnectionFailedException: BamError[type=cancel,group=remote-connection-failed,text=Cannot connect to http://127.0.0.1:6600/hmtp
  java.net.ConnectException: Connection refused]

Start Resin if not connected:

$ sudo resinctl start

Output:
Resin/4.0.27 launching watchdog at 127.0.0.1:6600
Resin/4.0.27 started -server 'app-0' with watchdog at 127.0.0.1:6600

The status should look something like this when you are connected:

$ resinctl status

Output:

Resin/4.0.27 status for watchdog at 127.0.0.1:6600

watchdog:
  watchdog-pid: 1829

server 'app-0' : ACTIVE
  password: ok
  watchdog-user: root
  user: www-data(www-data)
  root: /var/www
  conf: /etc/resin/resin.xml
  pid: 2021
  uptime: 0 days 00h00

Download MySQL Jar file

Download and unpack the MySQL Jar file.

http://dev.mysql.com/downloads/connector/j/5.1.html

Unpack it:

$ cd ~
$ cd Downloads/
$ tar xzvf mysql-connector-java-5.1.19.tar.gz 

Create driver deploy directory and install MySQL jar file with config file

Resin can monitor and manage database connection. In order to do this you need to use JNDI. It also good to enable JNDI for production so that a select few in operations can control the user name and password of the production system databases. Having JNDI allows your dev box and your prod box to have different usernames and passwords as well without rebuilding a special war file for each.

In this tutorial our dev box is Ubuntu and our prod box is Amazon AMI in the sky.

Now we need to add a JNDI entry for our MySQL database to Resin and deploy the JDBC driver to Resin. You could do this manually. If you use the command line deployment, then it is easy to deploy the driver and the conf xml file to the cloud.

Create a config directory and populate it:

$ cd ~
$ mkdir blogDBDeploy
$ cd blogDBDeploy/
$ mkdir resin-inf
$ mkdir resin-inf/blog-db
$ cd resin-inf/blog-db

A config directory can have both jar files and Resin XML config files in it. In our case we are going to deploy the MySQL driver (jar file) and the XML file that configures our blogdb database in JNDI.

Copy the MySQL jar file into ~/blogDBDeploy/resin-inf/blog-db.

$ pwd

Output:
~/blogDBDeploy/resin-inf/blog-db

$ mkdir lib
$ cp ~/Downloads/mysql-connector-java-5.1.19/*.jar lib
$ ls lib

Output:
mysql-connector-java-5.1.19-bin.jar

Create the file ~/blogDBDeploy/resin-inf/blog-db/blog-database-conf.xml

$ cd ..
$ nano blog-database-conf.xml

And add the contents as follows:

<resin xmlns="http://caucho.com/ns/resin"
      xmlns:resin="urn:java:com.caucho.resin">

<database jndi-name="jdbc/blogdb">
        <driver type="com.mysql.jdbc.Driver">
                 <url>jdbc:mysql://localhost:3306/blogdb</url>
                 <user>bloguser</user>
                 <password>roofoo</password>
         </driver>
</database>

</resin>

Now we can deploy this whole directory, jar file and configuration file to Resin in one swope using resinctl config-deploy. First let's use resinctl help system to give us some more information.

Run config deploy from the root of blogDBDeploy:

$ pwd
~/blogDBDeploy

Let's look at the options for config-deploy:

$ resinctl help config-deploy
usage: resinctl config-deploy [--options]

  deploys a configuration directory or jar file

where options include:
  --address <ip>         : IP address or host name of (triad) server
  --conf <file>          : alternate resin.xml file
  --license-directory <dir> : alternate license directory
  --log-directory <dir>  : alternate log directory
  --m <message>          : commit message
  --mode <string>        : select .resin properties mode
  --password <password>  : admin password for authentication
  --port <port>          : IP port of (triad) server
  --resin-home <dir>     : alternate resin home
  --root-directory <dir> : alternate root directory
  --server <id>          : id of a server in the config file
  --stage <stage>        : stage to deploy application to, defaults to production
  --user <user>          : admin user name for authentication
  --user-properties <file> : select an alternate $HOME/.resin file
  --verbose              : produce verbose output
  --version <version>    : version of application formatted as <major.minor.micro.qualifier>

If we don't specify the address and the port, then it will deploy locally to our dev box. Later when we want to deploy to Amazon WS, we just need to specify its address and port of our remote server in the cloud.

First let's deploy our config to our dev box.

Let's briefly reivew what we are deploying (the directory structure and the files):

$ ls -R
.:
resin-inf

./resin-inf:
blog-db

./resin-inf/blog-db:
blog-database-conf.xml  lib

./resin-inf/blog-db/lib:
mysql-connector-java-5.1.19-bin.jar

Now let's deploy it:

$ cd ..
$ pwd

Output:
~


$ resinctl config-deploy blogDBDeploy/

Output:
Deployed production/config/resin from blogDBDeploy to hmux://127.0.0.1:6800

To verify that our deploy worked, lets run resinctl config-ls, and resinctl config-cat:

$ resinctl config-ls

Output:
resin-inf/blog-db/blog-database-conf.xml
resin-inf/blog-db/lib/mysql-connector-java-5.1.19-bin.jar

$ resinctl config-cat resin-inf/blog-db/blog-database-conf.xml

Output:
<resin xmlns="http://caucho.com/ns/resin"
      xmlns:resin="urn:java:com.caucho.resin">

<database jndi-name="jdbc/blogdb">
        <driver type="com.mysql.jdbc.Driver">
                 <url>jdbc:mysql://localhost:3306/blogdb</url>
                 <user>bloguser</user>
                 <password>roofoo</password>
         </driver>
</database>

</resin>

Blog Project with Eclipse

If you already have a war file that you want to deploy, then you can skip this section.

Use Eclipse for Java EE Indigo or higher.

If you know how to create a new project using Eclipse and Resin Java EE environment, just go ahead and do it now.

Otherwise follow these instructions:

Using Eclipse Indigo

1. Go to File menu -> New Project -> Dynamic Web Project
2. In New Dynamic Web Project Dialog-> New Runtime...
3. In New Runtime Dialog -> Download Additional Server Adapters -> Select Resin (Java EE Web Profile) 4.0.24
4. (Click Next and Ok until it installs Resin runtime)
5. (Eclipse needs to restart)
6. File -> New Project -> Dynamic Web Project
7. In New Dynamic Web Project Dialog-> New Runtime...->Select Resin->Check create local server checkbox
8. Step 2 of New Runtime...->Click Download and Install
9. Fill out project name etc. (blog).
10. (Click Next and Ok until you are done)

After the project is setup, do the following:

File->New->Servlet (Name the new Servlet example.BlogServlet)

LEFT OFF HERE 4/6/2012...

Setup RDS database

Setup an RDS database using MySQL 5.1.7 (or as close to your MySQL as possible).

I use the same username password to make it simple. The only part that is going to change for sure is the URL.

Using the AWS web console modify the user-data of the resinserver we deployed earlier and add three properies.

user-data on resin server

blogdb.url : blogdb.cvolnlau763z.us-east-1.rds.amazonaws.com
blogdb.user : bloguser
blogdb.password : roofoo

Note that the URL should be the url of the Amazon RDS database that you just setup. Also you need to setup a database security group that allows the group of your vm instance access the database.

Start up the VM instance that we installed Resin on earlier and create a database.xml file in the /etc/resin/local.d/ as follows:

/etc/resin/local.d/database.xml Create database.properties on remote Amazon instance.

<resin xmlns="http://caucho.com/ns/resin"
      xmlns:resin="urn:java:com.caucho.resin">

<database jndi-name="jdbc/blogdb">
        <driver type="com.mysql.jdbc.Driver">
                 <url>jdbc:mysql://${blogdb.url}:3306/blogdb</url>
                 <user>${blogdb.user}</user>
                 <password>${blogdb.password}</password>
         </driver>
</database>
</resin>

Next install the mysql driver on the Amazon instance.

$ sudo yum install mysql-connector-java
$ sudo cp /usr/share/java/mysql-connector-java.jar /usr/local/share/resin/lib/

Now deploy the war file to the Amazon AMI

 $ resinctl deploy target/blog-0.1.0.BUILD-SNAPSHOT.war -name blogdb -address 107.22.13.146 \
                                                                     -port 8080 -user admin -password roofoo

Now test it out: http://ec2-107-22-13-146.compute-1.amazonaws.com:8080/blogdb/blogs/1

It worked for me. :)