Good news everone, we are all super happy to tell you our JVM image has been updated substantialy. We now support OpenJDK 12 and GraalVM CE!

If you follow what's going on in the JVM space you have seen there is more and more choices available when it comes to running JVM-based applications. And we now support GraalVM CE. If you have no idea what it is, the best, simple explaination can be found on Julien Ponge's medium: https://medium.com/@jponge/the-graalvm-frenzy-f54257f5932c

And as he explains that way better than I, I will jump into the how to run a GraalVM application on Clever Cloud.

We first need to find an appropriate Hello world project. Being a Ratpack fan I looked on Github and found this: https://github.com/wololock/ratpack-graalvm-demo

This is a gradle project with a script to build a native image, basically a binary with everything needed to run the application. No need for a JVM. So this is what we are going to build.

First to create the application, if you have clever-tools you can run: clever create --type gradle --plan M graalPack Now we need to setup the right environment variables.

clever env set CC_JAVA_VERSION graalvm-ce  # Select GraalVN CE as Java Version
clever env set GRADLE_DEPLOY_GOAL shadowJar # Specify the gradle goal, here we want to build a full jar.
clever env set CC_PRE_RUN_HOOK ./build-native-image.sh # run the native image build
clever env set CC_RUN_COMMAND ./ratpack-graalvm-demo # specify the path of the native executable

I have modified a couple of things to make sure it would work smoothly on Clever Cloud. First thing, always define a rootProject name because gradle will pick the containing folder, which in our case the random application id, and generate the jar name with it. So you can't really use it in a script. Here's one liner to do it: echo 'rootProject.name = "ratpack-graalvm-demo"' > settings.gradle

The script already run gradlew shadowJar. I have removed it since this step is already made by Clever Cloud. Of course you could run it locally and only push the executable. This would also work.

Don't forget to add these changes to your git repository: git add settings.gradle build-native-image.sh && git commit -m"cleverify"

We are building a native image and this can be a super greedy process in terms of memory. To make sure we have some headroom we are going to use a bigger scaler. Run clever scale --flavor L to get the proper size. This might depend on the build you are running. Static analysis is not cheap. Later this week we'll show you how to proceed differently with a new CI project :) But for now we'll stick to a bigger scaler.

Now all you have to do is run clever deploy and you will have your native image running on Clever Cloud. Benefits are mostly a reduced memory footprint and better performances at cold start. You can find more informations about this on the following blog post Ratpack on GraalVM - how to start?.

In the next days you can expect support for cool GraalVM features like the support for TruffelRuby or FastR). Let us know if you have any questions in the comments below!

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Vert-x and Golo.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at Vert-x and Golo.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Vert-x?

Eclipse Vert.x is a tool-kit for building reactive applications on the JVM.

And when they write JVM, they mean it. You can use any JVM language. Beyond the polyglot statement, you will find out that it's also event driven and non blocking. Which means it's ready to scale and will use your hardware as much as possible. It's reactive. I invite you to read the Reactive Manifesto if you have no idea what it is. Vert-x is unopinionated and as such is a good fit for any kind of application or microservice. Here we will use it to build an API.

What is Golo

A lightweight dynamic language for the JVM.

You can install Golo with a standalone binary available on their website. It's important because today we will also look at how to create a Golo project from scrach instead of using an existing one. All of this is happening thanks to our CSO Philippe Charrière who previously blogged on this subject, check out his blog!

Create a Golo Project

In a terminal, type these commands:

golo new vertx.golo.demo --type maven
cd vertx.golo.demo

The Golo CLI has generated a Golo project:

.
├── pom.xml
├── src
│   └── main
│       └── golo
│           └── main.golo

To make sure you can compile the project, you have to update the pom.xml file: Change the Golo version by replacing

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <golo.version>3.2.0-SNAPSHOT</golo.version>
  </properties>

with:

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <golo.version>3.2.0</golo.version>
    <vertx.version>3.4.1</vertx.version>
  </properties>

Add some dependencies and the bintray repository:

  <dependencies>
    <dependency>
      <groupId>org.eclipse.golo</groupId>
      <artifactId>golo</artifactId>
      <version>${golo.version}</version>
    </dependency>

    <dependency>
      <groupId>com.googlecode.json-simple</groupId>
      <artifactId>json-simple</artifactId>
      <version>1.1.1</version>
    </dependency>

    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-core</artifactId>
      <version>${vertx.version}</version>
    </dependency>

    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web</artifactId>
      <version>${vertx.version}</version>
    </dependency>

  </dependencies>

  <repositories>
    <repository>
      <id>bintray</id>
      <name>Bintray</name>
      <url>https://jcenter.bintray.com</url>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>bintray</id>
      <name>Bintray</name>
      <url>https://jcenter.bintray.com</url>
    </pluginRepository>
  </pluginRepositories>

We are going to write a very simple Vert-x web application with Golo. For that, replace the content of /src/main/golo/main.golo with this:

module vertx.golo.demo

import io.vertx.core.Vertx
import io.vertx.core.http.HttpServer
import io.vertx.ext.web.Router
import io.vertx.ext.web.handler

import gololang.JSON

let vertx = Vertx.vertx()

function main = |args| {

  let server = vertx: createHttpServer()
  let router = Router.router(vertx)
  router: route(): handler(BodyHandler.create())

  let port =  Integer.parseInt(System.getenv(): get("PORT") orIfNull "8080")

  router: get("/"): handler(|context| {
    context: response(): putHeader("content-type", "text/html;charset=UTF-8")
    context: response(): end("<h1>Hello 🌍</h1>", "UTF-8")
  })

  router: get("/hi"): handler(|context| {
    context: response(): putHeader("content-type", "application/json;charset=UTF-8")
    context: response(): end(JSON.stringify(DynamicObject(): message("Hi 😛")), "UTF-8")
  })

  server: requestHandler(|httpRequest| -> router: accept(httpRequest)): listen(port)

  println("listening on " + port)
}

To test the application:

• Built it with: mvn package
• Run it with: mvn exec:java
• Test your web application by opening http://localhost:8080 and http://localhost:8080/hi

If it works locally then you are ready for the next step. Set it up for Clever Cloud.

Setup

Clever Cloud can run any JVM code packaged as a .war or .jar. You can either checkout those files directly in your Github repository or have them built with Maven or Gradle. In this case it's a Maven build that generates a .jar file from some Golo code. So when we create the application we have to select maven as type: clever create --type maven vertx-golo-sample

The only configurable thing is the port of the server. It defaults to 8080 in the code. It's also the case for each application running on Clever Cloud as it is required. So nothing to change here, we are ready to deploy.

Deploy

To make our Maven buikd work we need to state which build goal is needed and where is the .jar file to run. To do so create in your project directory a clevercloud directory with a jar.json file containing:

{
  "build": {
    "type": "maven",
    "goal": "package"
  },
  "deploy": {
    "jarName": "target/vertx.golo.demo-0.0.1-SNAPSHOT-jar-with-dependencies.jar"
  }
}

It configures your application to run mvn package then java -jar target/vertx.golo.demo-0.0.1-SNAPSHOT-jar-with-dependencies.jar.

The last step to deploy it is to initiate an empty git repository, add and commit your code, then deploy it:

git init
git add src/ pom.xml clevercloud/
git commit -m "first version"
clever deploy

What clever deploy does is pushing your code to a remote git branch that was created when you created the application in the setup step. Right now you should start seeing build logs in the console. If everything worked well run clever open. It will take you straight to your web application and display Hello 🌍!

What is Ratpack?

• Ratpack is a set of Java libraries for building modern HTTP applications.
• It provides just enough for writing practical, high performance, apps.
• It is built on Java 8, Netty and reactive principles.

Setup

• Create the application: clever create --type gradle ratpackTest --region par
• Link the add-on: clever service link-addon ratpackPG

db:
  username: ${POSTGRESQL_ADDON_USER}
  password: ${POSTGRESQL_ADDON_PASSWORD}
  database: ${POSTGRESQL_ADDON_DB}
  poolSize: 4
  hostname: ${POSTGRESQL_ADDON_HOST}
  port: ${POSTGRESQL_ADDON_PORT}

clever env set RATPACK_PORT 8080
clever env set db_database \${POSTGRESQL_ADDON_DB}
clever env set db_hostname \${POSTGRESQL_ADDON_HOST}
clever env set db_password \${POSTGRESQL_ADDON_PASSWORD}
clever env set db_port \${POSTGRESQL_ADDON_PORT}
clever env set db_username \${POSTGRESQL_ADDON_USER}
clever env set db_poolSize 4

public Observable<Product> getProducts() {
  return pool.queryRows("select * from product").map(row -> {
    Long id = row.getLong("product_id");
    String name = row.getString("name");
    String description = row.getString("description");
    Boolean available = row.getBoolean("is_available");
    BigDecimal price = row.getBigDecimal("price");
    return new Product(id, name, description, available, price);
  }).doOnError(Throwable::printStackTrace);
}

CREATE TABLE public.product (
   product_id   bigint,
   name   text,
   description   text,
   is_available   boolean,
   price   double precision
);
INSERT INTO product(product_id, name, description, is_available, price)
       VALUES (1, 'product name','product description', true, 20.00);

touch data.sql
echo "CREATE TABLE public.product (product_id   bigint,   name   text,   description   text,   is_available   boolean,   price   double precision); INSERT INTO product(product_id, name, description, is_available, price) VALUES (1, 'product name','product description', true, 20.00);" > data.sql

Deploy

{
  "deploy": {
    "goal": "run"
  }
}

git add clevercloud/gradle.json src/main/resources/application.yml
git commit -m"add clever cloud specifics"