Spring onto Heroku


Spring onto Heroku

Andreas Kollegger
Deploying your application into the cloud is a great way to scale from “wouldn’t it be cool if..” to giving interviews to Forbes, Fast Company, and Jimmy Fallon. Heroku makes it super easy to provision everything you need, including a Neo4j Add-on. With a few simple adjustments, your Spring Data Neo4j application is ready to take that first step into the cloud.
Let’s walk through the process, assuming this scenario:
  • you have an account on Heroku, and have installed the heroku tool
  • git is your friend 
  • you’ve developed a killer Spring MVC application 
  • and of course you’re using Spring Data Neo4j 
Ready? OK, first let’s look at your application.

Create a Self-Hosted Web Application 
Usually, a Spring MVC application is bundled into a war and deployed to an application server like Tomcat. But Heroku can host any kind of Java application; it just needs to know what to launch. So, we’ll transform the war into a self-hosted servlet using an embedded Jetty server, then add a start-up script to launch it.
First, add the dependencies for Jetty to the pom.xml:


org.eclipse.jetty
jetty-webapp
7.4.4.v20110707


org.mortbay.jetty
jsp-2.1-glassfish
2.1.v20100127

Then change the scope of the servlet-api artifact from provided to compile. This library is normally provided at runtime by the application container. Since we’re self-hosting, it needs to be included directly. Make sure the servlet-api dependency looks like this:

javax.servlet
servlet-api
2.5
compile

We could provide a complicated command-line to Heroku to launch the app. Instead, we’ll simplify the command-line by using the appassembler-maven-plugin to create a launch script. Add the plugin to your pom’s build/plugins section:

org.codehaus.mojo
appassembler-maven-plugin
1.1.1


package
assemble

target
-Xmx512m


Main
webapp






Finally, switch the packaging from war to jar. That’s it for the pom. Now that the application is ready to be self-hosted, create a simple Main to bootstrap Jetty and host the servlet. The pom snippet above assumes a src/main/java/Main.java that looks like:
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.webapp.WebAppContext;
public class Main {
public static void main(String[] args) throws Exception {
String webappDirLocation = "src/main/webapp/";
String webPort = System.getenv("PORT");
if(webPort == null || webPort.isEmpty()) {
webPort = "8080";
}
Server server = new Server(Integer.valueOf(webPort));
WebAppContext root = new WebAppContext();
root.setContextPath("/");
root.setDescriptor(webappDirLocation+"/WEB-INF/web.xml");
root.setResourceBase(webappDirLocation);
root.setParentLoaderPriority(true);
server.setHandler(root);
server.start();
server.join();
}
}
Notice the use of environment variable PORT for discovering which port to use. Heroku and the Neo4j Add-on use a number of environment variables to configure the application.
Next, we’ll modify the Spring application context to use the Neo4j variables for specifying the connection to Neo4j itself.
For example, if you have src/main/resources/META-INF/spring/applicationContext-graph.xml, then modify it to look like this:






Before provisioning at Heroku, test the application locally. First make sure you’ve got Neo4j server running at https://localhost:7474, using default configuration. Then set the following environment variables (here, assuming bash):
export NEO4J_REST_URL=https://localhost:7474/db/data
export NEO4J_LOGIN=""
export NEO4J_PASSWORD=""
Now you can launch the app by running sh target/bin/webapp. If all went well, your application will be available just as if it were in a Tomcat container.

Deploy to Heroku 
With a self-hosted application ready, deploying to Heroku needs a few more steps. First, create a Procfile at the top-level of the project, which will contain a single line identifying the command line which launches the application. The contents of the Procfile should contain one line:
sh target/bin/webapp
Then use git to magically deploy to Heroku:
# Initialize a local git repository, adding all the project files
git init
git add .
git commit -m "initial commit"
# Provision a Heroku stack, add the Neo4j Add-on and deploy the appication

heroku create --stack cedar
heroku addons:add neo4j
git push heroku master
Note that the heroku stack must be “cedar” to support running Java. Check that the process is running by using heroku ps, which should show a “web.1” process in the “up” state.
Success! Your application is now live in the cloud.
To see the Neo4j graph you just created through Heroku, use heroku config to reveal the NEO4J_URL environment variable, which will take you to Neo4j’s Webadmin.

Summary
All that typing really comes down to three steps:
  1. make your application self-hosting
  2. access Heroku environment variables for configuration
  3. deploy to the cloud
Now go upgrade your application and join us in the cloud. It’s always sunny up here.

Cheers,
Andreas



Want to learn more about graph databases? Click below to get your free copy of O’Reilly’s Graph Databases ebook and discover how to use graph technologies for your application today.

Download My Ebook