{"id":31826,"date":"2014-10-26T15:00:35","date_gmt":"2014-10-26T13:00:35","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=31826"},"modified":"2014-10-26T14:15:46","modified_gmt":"2014-10-26T12:15:46","slug":"spring-boot-java-8-tomcat-8-on-openshift-with-diy","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2014\/10\/spring-boot-java-8-tomcat-8-on-openshift-with-diy.html","title":{"rendered":"Spring Boot \/ Java 8 \/ Tomcat 8 on Openshift with DIY"},"content":{"rendered":"

DIY cartridge is an experimental cartridge that provides a way to test unsupported languages on OpenShift. It provides a minimal, free-form scaffolding which leaves all details of the cartridge to the application developer<\/em>. This blog post illustrates the use of Spring Boot \/ Java 8 \/ Tomcat 8 application with PostgreSQL service bound to it.<\/p>\n

Creating new application<\/h2>\n

Prerequisite<\/h2>\n

Before we can start building the application, we need to have an OpenShift free account and client tools installed.<\/p>\n

Step 1: Create DIY application<\/h2>\n

To create an application using client tools, type the following command:<\/p>\n

rhc app create boot diy-0.1<\/pre>\n
This command creates an application boot<\/em> using DIY<\/em> cartridge and clones the repository to boot<\/em> directory.<\/p>\n
Step 2: Add PostgreSQL cartridge to application<\/h2>\n
The application we are creating will use PostgreSQL database, hence we need to add appropriate cartridge to the application:<\/p>\n
rhc cartridge add postgresql-9.2 --app boot<\/pre>\n
After creating the cartridge, it is possible to check its status with the following command:<\/p>\n
rhc cartridge status postgresql-9.2 --app boot<\/pre>\n
Step 3: Delete Template Application Source code<\/h2>\n
OpenShift creates a template project that can be freely removed:<\/p>\n
git rm -rf .openshift README.md diy misc<\/pre>\n
Commit the changes:<\/p>\n
git commit -am \"Removed template application source code\"<\/pre>\n
Step 4: Pull Source code from GitHub<\/h2>\n
git remote add upstream https:\/\/github.com\/kolorobot\/openshift-diy-spring-boot-sample.git\r\ngit pull -s recursive -X theirs upstream master<\/pre>\n
Step 5: Push changes<\/h2>\n
The basic template is ready to be pushed:<\/p>\n
git push<\/pre>\n
The initial deployment (build and application startup) will take some time (up to several minutes). Subsequent deployments are a bit faster, although starting Spring Boot application may take even more than 2 minutes on small Gear:<\/p>\n
Tomcat started on port(s): 8080\/http\r\nStarted Application in 125.511 seconds<\/pre>\n
You can now browse to: http:\/\/boot-yournamespace.rhcloud.com\/manage\/health<\/a> and you should see:<\/p>\n
{\r\n    \"status\": \"UP\",\r\n    \"database\": \"PostgreSQL\",\r\n    \"hello\": 1\r\n}<\/pre>\n
You can also browser the API. To find out what options you have, navigate to the root of the application. You should see the resource root with links to available resources:<\/p>\n
{\r\n  \"_links\" : {\r\n    \"person\" : {\r\n      \"href\" : \"http:\/\/boot-yournamespace.rhcloud.com\/people{?page,size,sort}\",\r\n      \"templated\" : true\r\n    }\r\n  }\r\n}<\/pre>\n
Navigating to http:\/\/boot-yournamespace.rhcloud.com\/people<\/a> should return all people from the database.<\/p>\n
Step 6: Adding Jenkins<\/h2>\n
Using Jenkins has some advantages. One of them is that the build takes place in it\u2019s own Gear. To build with Jenkins, OpenShift needs a server and a Jenkins client cartridge attached to the application. Creating Jenkins application:<\/p>\n
rhc app create ci jenkins<\/pre>\n
And attaching Jenkins client to the application:
 
<\/div> <\/div><\/p>\n
rhc cartridge add jenkins-client --app boot<\/pre>\n
You can now browse to: http:\/\/ci-<\/a>.rhcloud.com and login with the credentials provided. When you make next changes and push them, the build will be triggered by Jenkins:<\/p>\n
remote: Executing Jenkins build.\r\nremote:\r\nremote: You can track your build at https:\/\/ci-<namespace>.rhcloud.com\/job\/boot-build\r\nremote:\r\nremote: Waiting for build to schedule.........<\/pre>\n
And when you observe the build result, the application starts a bit faster on Jenkins.<\/p>\n
Under the hood<\/h2>\n
Why DIY?<\/h2>\n
Spring Boot application can be deployed to Tomcat cartridge on OpenShift. But at this moment no Tomcat 8 and Java 8 support exists, therefore DIY was selected. DIY has limitations: it cannot be scaled for example. But it is perfect for trying and playing with new things.<\/p>\n
Application structure<\/h2>\n
The application is a regular Spring Boot application, that one can bootstrapped with http:\/\/start.spring.io<\/a>. Build system used is Maven, packaging type is Jar. Tomcat 8 with Java 8 used. Spring Boot uses Tomcat 7 by default, to change it the following property was added:<\/p>\n
<properties>\r\n    <tomcat.version>8.0.9<\/tomcat.version>\r\n<\/properties><\/pre>\n
The Maven was selected, since currently only Gradle 1.6 can be used on OpenShift. This is due to a bug in Gradle<\/a>. Gradle 2.2 fixes this issue.<\/p>\n
Maven settings.xml<\/h2>\n
The settings.xml<\/code> file is pretty important, as it contains the location of Maven repository: ${OPENSHIFT_DATA_DIR}\/m2\/repository<\/code>.<\/p>\n
On OpenShift, write permissions are only in $OPENSHIFT_DATA_DIR.<\/p>\n
Data source configuration<\/h2>\n
The application uses Spring Data REST to export repositories over REST. The required dependencies are:<\/p>\n