Thursday, January 5, 2012

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 http://localhost:7474, using default configuration. Then set the following environment variables (here, assuming bash):
export NEO4J_REST_URL=http://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

6 comments:

Hatim said...

Hello,

I think that mainClass needs to be correct or it can file an error (along the lins of cannot set property)

I followed code from here to get a basic app up and running. https://github.com/heroku/devcenter-java

Andreas Kollegger said...

Thanks Hatim, I hadn't noticed that blogger dropped the mixed-case when pasting code in. I've updated the pom snippets.

Cheers,
Andreas

Findings said...

Hello Andreas,

I would like to participate in the Neo4j Challenge... I think it is very cool and I might have four (4) Neo4j/Spring Data apps ready for deploying.

I followed the steps on Gensen and it seems that participants must go through the heroku billing process. Which I think it is an unnecessary requirement for community members that would like to contribute with source code to the Neo4j cause.

Thank you in advance for your comments on this regard.

jd @ http://pragmatikroo.blogspot.com

Andreas Kollegger said...

Hm, jd. That is an excellent observation. While our intent is to encourage projects that are deployable into Heroku, contributions should not incur a cost.
A Heroku account should just require the billing information, without any actual cost. There would only be a charge for running the application on multiple dynos, or adding a paid-for add-on.
But, we could also consider modifying gensen to enable submission of any git url. What do you think about that approach?

Best,
Andreas

Findings said...

Andreas,

Yes, yes no billing process at all please... requiring developer's cc info.

Your suggestion sounds perfect to me.

I will be checking Gensen regularly for learning the new deploying steps.

Thank You
jD

human mathematics said...

You may not know super a lot about your competitors, but it would be useful for me (as a possible user but not there yet) if you wrote a little piece contrasting your graph DB with other ones out there. TIA