Migrate a Java web application from Amazon Web Services -

Migrate a Java web application from Amazon Web Services

Last updated on: 2018-10-24

Authored by: Rackspace Support

Previous section: Provision cloud resources when migrating from Amazon Web Services

This article shows you how to migrate an Apache® Tomcat® and Java™-based Spring web application from Amazon® Web Services® (AWS) to Rackspace Cloud. This example takes about 30 minutes to complete.

The example uses the Spring PetClinic Sample Application.

The following figure shows the application’s topology:

Prerequisites

The following prerequisites are required to follow the example in this article:

An Amazon Elastic Compute Cloud (EC2) instance on AWS with root access that’s running the Spring web application on Apache Tomcat.
A valid and enabled account on Rackspace Cloud.

Preparation

Take the following steps before you attempt to follow the steps in the exercise:

Identify the resources that you want to migrate, including application and database resources.
Create a list of all of the necessary software packages that are installed on your EC2 instance, other than your Spring application.
Create a list of all additional Amazon servers that the application uses (for example, Simple Email Server (SES) for email or Relational Database Service (RDS) for databases).
If you haven’t already, create a Cloud Server instance and any supporting Rackspace Cloud services.

Install software packages

Install the following software packages:

Oracle® Open Java Development Kit (OpenJDK™)
Apache Tomcat
OpenStack® Swift (optional)

Install OpenJDK on the cloud

Complete the following steps to install OpenJDK on the cloud:

Using Secure Shell (SSH), connect to the Cloud Servers instance by using the Rackspace PublicNet URL and the root password.
Enter the root password to log in.
Install OpenJDK 7 by entering the following command:
```
sudo yum install java-1.7.0-openjdk-devel
```
Determine the location of JAVA_HOME by entering the following command:
```
ll /etc/alternatives/java
```
In the following example output, JAVA_HOME is located at /usr/lib/jvm/jre-1.7.0-openjdk.x86_64:
```
/etc/alternatives/java -> /usr/lib/jvm/jre-1.7.0-openjdk.x86_64/bin/java
```

Install Tomcat on the Cloud Server

Use the following steps to install Tomcat on the Cloud Server:

Right-click the version of Tomcat that you want to use from the Tomcat 7 Software Downloads page and copy the URL of the tar.gz file (for example, https://www.us.apache.org/dist/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz).
Enter the following commands to change directory to /usr/share (or the directory that you want to use) and download the binary file:
```
 cd /usr/share
 sudo wget https://www.us.apache.org/dist/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz
```
Change permissions by entering the following command:
```
 sudo chmod 775 apache-tomcat-7.0.39.tar.gz
```
Extract the file contents by entering the following command:
```
 sudo tar zxvf apache-tomcat-7.0.39.tar.gz
```
After you extract Tomcat, use the following command to remove the tar.gz file and free up space:
```
 sudo rm apache-tomcat-7.0.39.tar.gz
```
Set the environment variables in the catalina.sh file by entering the following commands:
```
 cd /usr/share/apache-tomcat-7.0.39/bin
 sudo vi catalina.sh
```
Add the following line to the catalina.sh file immediately after \#!/bin/sh:
```
 JAVA_HOME=/usr/lib/jvm/jre-1.7.0-openjdk.x86_64
```
Save your changes and exit the file.
Automate Tomcat startup by entering the following commands:
```
 cd /etc/init.d
 sudo vi tomcat
```

Add the following information to the file. Ensure that JAVA_HOME, TOMCAT_HOME, START_TOMCAT, and STOP_TOMCAT refer to the correct directories:

#!/bin/bash
# chkconfig: 234 20 80
# description: Tomcat Server basic start/shutdown script
# processname: tomcat
JAVA_HOME=/usr/lib/jvm/jre-1.7.0-openjdk.x86_64
export JAVA_HOME
TOMCAT_HOME=/usr/share/apache-tomcat-7.0.39/bin
START_TOMCAT=/usr/share/apache-tomcat-7.0.39/bin/startup.sh
STOP_TOMCAT=/usr/share/apache-tomcat-7.0.39/bin/shutdown.sh
start() {
echo -n "Starting tomcat: "
cd $TOMCAT_HOME
${START_TOMCAT}
echo "done."
}
stop() {
echo -n "Shutting down tomcat: "

cd $TOMCAT_HOME
${STOP_TOMCAT}
echo "done."
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
stop
sleep 10
start
;;
*)
echo "Usage: $0 {start|stop|restart}"
esac
exit 0

Save your changes and exit the file.

Set file permissions, set up Tomcat as a system service, and test the setup by entering the following commands:

sudo chmod 755 tomcat
sudo /sbin/chkconfig --add tomcat
sudo /sbin/chkconfig --level 234 tomcat on
sudo /sbin/chkconfig --list tomcat

The output should be similar to the following example:

 tomcat 0:off 1:off 2:on 3:on 4:on 5:off 6:off

Because Tomcat is running on port 8080, you need to ensure that iptables doesn’t interfere with connectivity.
To test Tomcat, look up the Internet Protocol (IP) address for the Cloud Server in the Cloud Control Panel and open the URL in a browser (for example, https://<ipAddress>:8080/). The Apache Tomcat landing page should appear.

Note: You can stop and start Tomcat by using the following commands:
```
sudo /sbin/service tomcat stop
sudo /sbin/service tomcat start
```

Install OpenStack Swift (optional)

If you plan to use Cloud Files to transfer your data, you need to use OpenStack Swift to enable access from your server. Follow the steps in this section to install and configure OpenStack Swift.

Use the following command to install the OpenStack Swift client:

 sudo yum install python-novaclient python-glanceclient swift

Set the necessary environment variables by running the following commands, substituting your Rackspace Cloud account username and API key:
```
 export ST_USER=<yourLoginUsername>
 export ST_KEY=<yourApiKey>
 export ST_AUTH=https://identity.api.rackspacecloud.com/v1.0/
```
You might want to define these variables in your .bashrc or .bash\_profile file. If you perform this step, you must reload the file with the following source command, substituting .bash\_profile for .bashrc if necessary:
```
     source .bashrc
```
Type swift list and ensure that you can see the container that you created to hold your data.

Back up data from AWS to Rackspace Cloud Files

Retrieve your data from AWS EC2. You can use one of the following methods to transfer the data:

Transfer the data directly by using rsync or SSH File Transfer Protocol (SFTP).
Use the OpenStack Swift client to transfer your data to Cloud Files, and then transfer the data from Cloud Files to the Cloud Server.

Complete the following preparatory steps to use Cloud Files:

Use the following commands to connect to your EC2 instance by using SSH:

ssh -i yourPrivateKey.pem user@ec2-xxx-xxx-xxx-xxx.compute-1.amazonaws.com

Perform a database dump by using the following command:

mysqldump -h <rdsHostname> -u <rdsUsername> -p --triggers --routines --databases petclinic | gzip > ~/petclinic.sql.gz

Use the following command to back up your application and any other resources that the application needs, including logs and other directories:
```
# Ensure that you have the correct tomcat7 directory
sudo tar cvzf ~/tomcat.tar.gz /usr/share/tomcat7/webapps/*
```
If you’re using Cloud Files to transfer your files, use one of the following methods to perform the transfer. If you’re transferring files directly by using rsync or SFTP, skip to the final section of this article.
- Enter the following commands to upload your archives to the Cloud Files container (Tomcat in this example) by using the Swift client:
```
swift upload Tomcat petclinic.sql.gz
swift upload Tomcat tomcat.tar.gz
```
- Use the following steps to upload your data to Cloud Files through the Cloud Control Panel:
  1. From the Select a Product drop-down menu, select Rackspace Cloud > Storage > Files > containerName to open your container.
  2. Click Upload Files.
  3. Click Browse, select the file or files that you want to upload, and click Open, Select, or Choose (depending on the browser and system that you’re using).
  4. Click Upload File.

Restore data from Cloud Files to Cloud Servers

If you uploaded your data to Cloud Files, use the following steps to transfer it to your Cloud Server:

Using SSH, connect to the Cloud Servers instance by using the PublicNet URL and the root password.
Install and configure the Swift command-line interface (CLI) by following the steps in the “Install software packages” section of this article.
Ensure that you can execute the swift list command and see the new container that you created in the results.
Use the following commands to download the database dump from the backup that you took in the “Back up data from AWS to Rackspace Cloud Files” section of this article and restore it locally:
```
swift download Tomcat petclinic.sql.gz
gunzip < petclinic.sql.gz | mysql -u <cloudDatabaseUsername> -p -h <cloudDatabaseHostname>
```

Use the following commands to stop Tomcat and download and extract the application files:

sudo /sbin/service tomcat stop
swift download Tomcat tomcat.tar.gz
tar -zxvf tomcat.tar.gz

Copy the extracted web application contents to the local Tomcat webapps directory and modify the application properties (including jdbc.url, the database user name, database password, and other properties).

In the Spring Framework Petclinic sample, comment out the following files:

 petclinic/WEB-INF/classes/db/mysql/initDB.sql
 petclinic/WEB-INF/classes/db/mysql/populateDB.sql

Use the following command to restart Tomcat:
```
sudo /sbin/service tomcat start
```

Test your application

Access the web application in your browser at https://<cloudServerIPAddress>:8080/petclinic.

Next step

Post-migration considerations when migrating from Amazon Web Services

For other migration scenarios, see the following articles:

Cloud Servers