Edit page

It is common to have a Java application that you want to migrate to Platform.sh. Platform.sh supports several styles of Java application, such as monolith, microservices, stateful, and stateless.

Minimum Requirement 

To run a Java application at Platform.sh you will need:

• A supported Java version
• A build management tool
  • Gradle
  • Maven
  • Maven Wrapper
  • Ant
• A Git Repository:
  • GitHub
  • BitBucket
  • GitLab
  • The default Git repository provided by Platform.sh

Monolith/Single Application 

To start a Java application, you need to understand the Platform.sh structure. At minimum you will need three YAML files:

1. Application
2. Route

Application 

# .platform.app.yaml

name: app
type: "java:<version>" [1]
disk: 1024
hooks:
    build: [2]
web:
    commands:
        start: [3]

1. A Java version, e,g.: java:11
2. The build defines what happens when building the application, This build process will typically generate an executable file such as a uber-jar e.g.: mvn clean package
3. The commands key defines the command to launch the application. E.g.: java -jar file.jar
4. In the start’s command needs to receive the port where the application will execute thought the PORT environment. That is trivial if your application follows the port bind principle. E.g.: java -jar jar --port=$PORT

Route 

# .platform/routes.yaml

"https://{default}/":
  type: upstream
  upstream: [1]
"https://www.{default}/":
  type: redirect
  to: "https://{default}/"

1. It defines the application will link in the route, e.g.: "app:http"

Microservices 

You have the option to use several languages in microservices. If you’re using Java there are several options to aggregate these services into a microservices:

• Maven Modules
• Gradle Multi-project
• Git submodules

Platform.sh supports multiple applications and there are two options:

• One application YAML file to each application
• Aggregate all applications in a single file with applications.yaml

Access to services included at Platform.sh 

Platform.sh has services managed by Platform.sh itself such as database, cache and search engine. However, you can use a database or any services such as a transition process, just be aware of the firewall.

When applications need to access a service, it is important to include the Relationships key, because. by default an application may not talk to any other container within a project it includes others projects as a microservices architecture.

To connect to a service from your deployed application, you will need to pass the relationships information into your application’s configuration. The way to do so varies with the application. The most common mechanisms are listed below.

Overwrite 

If you are using a framework that follows the Twelve-Factor App methodology, particularly the third point, you will be able to configure the application directly from environment variables. Examples of such frameworks include Spring, Eclipse MicroProfile Config, Quarkus, and Micronauts.

The services information is available in the PLATFORM_RELATIONSHIPS environment variable. It is a base64-encoded JSON object whose keys are the relationship name and the values are arrays of relationship endpoint definitions.

Platform.sh supports jq that allows to extract information from this JSON.

export DB_HOST=`echo $PLATFORM_RELATIONSHIPS | base64 --decode | jq -r ".database[0].host"`

To reduce the number of lines in the application file and to make it cleaner, you have the option to move the variable environment to another file: the .environment file as part of your application.

E.g.:

export DB_HOST=`echo $PLATFORM_RELATIONSHIPS | base64 --decode | jq -r ".database[0].host"`
export DB_PASSWORD=`echo $PLATFORM_RELATIONSHIPS | base64 --decode | jq -r ".database[0].password"`
export DB_USER=`echo $PLATFORM_RELATIONSHIPS | base64 --decode | jq -r ".database[0].username"`
export DB_DATABASE=`echo $PLATFORM_RELATIONSHIPS | base64 --decode | jq -r ".database[0].path"`
export JDBC=jdbc:postgresql://${HOST}/${DATABASE}
export JAVA_MEMORY=-Xmx$(jq .info.limits.memory /run/config.json)m
export JAVA_OPTS="$JAVA_MEMORY -XX:+ExitOnOutOfMemoryError"

This .environment can interact to each application file. E.g.:

name: app
type: "java:11"
disk: 1024
hooks:
    build: ./mvnw package -DskipTests -Dquarkus.package.uber-jar=true
relationships:
    database: "db:postgresql"
web:
    commands:
        start: java -jar $JAVA_OPTS $CREDENTIAL -Dquarkus.http.port=$PORT jarfile.jar

Using Java Config Reader 

If your framework does not support configuration via environment variables, there is the Platform.sh Config Reader.This library provides a streamlined and easy to use way to interact with a Platform.sh environment. It offers utility methods to access routes and relationships more cleanly than reading the raw environment variables yourself. See the maven dependency.

import Config;

Config config = new Config();
MySQL database = config.getCredential("database", MySQL::new);
DataSource dataSource = database.get();