Oracle JRE and Kernel Tuning

2016-06-02 by Axel Fontaine

CloudCaptain's goal is to make you productive by making deployments of your Node.js and JVM-based applications truly effortless. And that's why we worked tirelessly to make it possible to deploy most applications out-of-the-box by issuing just a single boxfuse run command that uses convention-over-configuration with sensible defaults.

Some applications however require finer grained control, which is why we introduced customizing temp space allocation, restricting ports, dead-easy debugging and profiling and more.

Today we are introducing two new features to give you even more control: custom JREs and kernel tuning.

Custom JREs

By default CloudCaptain uses OpenJDK for JVM-based applications, with the possibility to opt for either the OpenJDK 7 or 8 headless JREs. This is a great open-source choice for the vast majority of the applications, both from a technical as well as from a legal perspective.

Some users however require commercial support or features only available with the Oracle JRE. Due to Oracle licensing restrictions we unfortunately cannot offer it as a component from the CloudCaptain Inventory as the Oracle JRE license explicitly prohibits standalone redistribution of the Oracle JRE.

However, starting today CloudCaptain now supports custom JREs. You can now bundle any Linux x64 Java Runtime Environment of your choice, including the Oracle JRE, directly with your application. CloudCaptain will then automatically use that JRE instead of the default OpenJDK one.

Using the Oracle JRE

Here is a small example of how to use the Oracle JRE with a Spring Boot application:

1. Download the Linux x64 JRE of your choice directly from the Oracle website.

2. Extract the /jre directory from the tar.gz distribution and add it to the src/main/resources folder of your application:

 my-spring-boot-app
   src
     main
       java
       resources
         jre
   bin
     java
     ...
   lib
     amd64
     ...
     rt.jar
     ...
   COPYRIGHT
   LICENSE
   ...

3. Package your application:

my-spring-boot-app> mvn package

4. Fuse a CloudCaptain image:

my-spring-boot-app> boxfuse fuse

5. Done! Your application now uses the Oracle JRE instead of the OpenJDK one when launched from that image.

Kernel Tuning

The other feature we are introducing today is kernel tuning. While most users will never need this, this is advanced feature can be a life-saver for expert users who require low-level tuning of the Linux kernel.

All you need for this is simply to ship a sysctl.conf file like the one below with their application:

net.ipv4.tcp_fastopen = 1
net.ipv4.tcp_fastopen_key = 00000000-00000000-00000000-00000000
net.ipv4.tcp_fin_timeout = 60
net.ipv4.tcp_frto = 2
net.ipv4.tcp_keepalive_intvl = 75
net.ipv4.tcp_keepalive_probes = 9
net.ipv4.tcp_keepalive_time = 7200
net.ipv4.tcp_limit_output_bytes = 131072

CloudCaptain will then automatically apply these settings on instance startup.

Conclusion

CloudCaptain is all about making you productive by making deployment of your apps truly effortless. With custom JREs and kernel tuning CloudCaptain now gives advanced users additional ways to customize their images.

Custom JREs now also allow you to easily run your applications using the Oracle JRE instead of OpenJDK and kernel tuning lets expert users to perform low-level tuning of the Linux kernel inside their images.

Existing CloudCaptain users can simply update with

> boxfuse -u

to use these features. Enjoy!

So if you haven't already, sign up for your CloudCaptain account now (simply log in with your GitHub id, it's free) to start deploying your JVM and Node.js applications effortlessly on AWS in minutes.