Skip to main content

Java

Getting an application running on Boltic is essentially working out how to package it as a deployable image. Once packaged, it can be deployed to the Boltic global application platform.

In this guide we’ll learn how to deploy a Java application on Boltic.

Note

Before starting this guide, ensure you have a Boltic account and have created a serverless app in your account.

Initial Local Setup​

Make sure that Java and Maven are installed on your local machine.

This allows you to run your project locally, and test that it works, before deploying it to Boltic.

tip

We recommend the latest supported versions of Java.

Create a new directory for your application and navigate into it:

# Create a new project directory
mkdir my-new-app

# Navigate to the project directory
cd my-new-app

Run an HTTP Server​

In this guide we recreate and deploy this minimal Java application to demonstrate how quickly Java apps can be deployed to Boltic!

tip

You can follow the guide to recreate the app or just git clone https://github.com/bolticio/serverless-samples.git to get a local copy.

Make sure to navigate to appropriate directory using: cd serverless-samples/java/applications/docker/hello-world

We assume you already have Java installed.

Create the HTTP Server​

The hello-world application is, as you’d expect for an example, very minimal.

Create a new file src/main/java/com/boltic/io/serverless/Index.java and add the following code:

Note

For Java, all serverless files should be in the src/main/java/com/boltic/io/serverless/ directory and the package name should be com.boltic.io.serverless.

// src/main/java/com/boltic/io/serverless/Index.java
package com.boltic.io.serverless;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class Index {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Index.class);
        Environment environment = app.run(args).getEnvironment();
        String devMode = Boolean.parseBoolean(environment.getProperty("DEVELOPMENT_MODE", "false")) ? "development" : "production";
        if ("development".equals(devMode)) {
            System.out.println("Listening for events on port " + environment.getProperty("APPLICATION_PORT", "8080") + " in development mode");
        } else {
            System.out.println("Listening for events");
        }
    }

    @Bean
    public WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> webServerFactoryCustomizer(Environment environment) {
        return factory -> {
            int port = Integer.parseInt(environment.getProperty("APPLICATION_PORT", "8080"));
            factory.setPort(port);
        };
    }

    @Bean
    public String devMode(Environment environment) {
        return Boolean.parseBoolean(environment.getProperty("DEVELOPMENT_MODE", "false")) ? "development" : "production";
    }

    @RestController
    @RequestMapping("/")
    class ServerController {

        private final Handler handler;
        private final String devMode;

        public ServerController(Handler handler, String devMode) {
            this.handler = handler;
            this.devMode = devMode;
        }

        @GetMapping("/**")
        public ResponseEntity<String> handleRequest() {
            return handler.handle(); // Handler should return ResponseEntity<String>
        }
    }
}
// src/main/java/com/boltic/io/serverless/Handler.java
package com.boltic.io.serverless;

import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

@Service
public class Handler {
    public ResponseEntity<String> handle() {
        try {
            // Prepare the response JSON
            String responseJson = "{\"message\": \"Hello World\"}";
            return ResponseEntity.ok().body(responseJson);
        } catch (Exception e) {
            // Handle errors
            e.printStackTrace();
            return ResponseEntity.status(500).body("Internal Server Error");
        }
    }
}

Start the Development Server​

Java apps can be run using the following commands:

Run without building​

mvn spring-boot:run

Build and Run​

mvn clean install
java -jar target/serverless-app.jar
# Output
Example app listening on port 8080!

If you open http://127.0.0.1:8080/ in your web browser, it displays Hello, World!.

Before Deployment ​

A few more steps are necessary before deploying the app.

In order to deploy the app to Boltic, you need to create a boltic.yaml/boltic.toml file in the root of your project. This file contains the configuration for the deployment. Read more about the Application Configuration for more information.

app: java-docker-app-sample
region: asia-south1
entrypoint: "src/main/java/com/boltic/io/serverless/Index.java"

build:
  builtin: dockerfile
  ignorefile: .gitignore

env:
  PORT: '8080'

The system will always refer to this file in the current directory if it exists, specifically for the app name/value at the start. That name will be used to identify the application to the Boltic service. The rest of the file contains settings to be applied to the application when it deploys:

  • primary_region: it configures where the primary region is, used to create the application;
  • builtin: it configures the builder to use the built-in Dockerfile strategy, which uses a system generated generic Dockerfile to build the application;
  • env: it configures the environment variables to set in the application.
info

This application is being built using the builtin strategy. This strategy uses a system-generated generic Dockerfile to build the application. The ignorefile key is used to specify the name of the file that contains the list of files and directories to be ignored during the build process. The ignorefile key is optional and if not provided, the default value is .dockerignore. For more information on the available builders in Boltic, check out the Builders page.

If you would rather like to use buildpacks to build your application, you can use the following configuration:

app: java-docker-app-sample
region: asia-south1
entrypoint: src/main/java/com/boltic/io/serverless/Index.java

build:
  builtin: dockerfile
  ignorefile: .gitignore

env:
  PORT: '8080'
  # https://github.com/cloudfoundry/java-buildpack/issues/663
  JAVA_OPTS: '-XX:ReservedCodeCacheSize=32M -XX:MaxDirectMemorySize=32M'
  JBP_CONFIG_OPEN_JDK_JRE: '[memory_calculator: {stack_threads: 30}]'
info

This application will now be built using the paketo-buildpacks/java buildpack. Learn more about Paketo Buildpacks.

Note

Java applications have certain limitations when run using buildpacks. The JAVA_OPTS and JBP_CONFIG_OPEN_JDK_JRE environment variables are set to work around these limitations. For more information, check out the Java Buildpack documentation on the operation of the Java buildpack and the GitHub issue explaining this in more detail.

Now, let’s move on to deploying this app to Boltic.

Deploy to Boltic​

We are now ready to deploy our app to Boltic. Ensure you have a Boltic account and have created a serverless app in your account.

tip

In order to clone the repository created for your app after registering it on the console, make sure you have added an SSH key to your Boltic account. You can find the instructions on how to add an SSH key in the SSH Keys section.

Initialize a new git repository in your project:

git init --initial-branch=main

Add a new origin to your local git repository:

git remote add boltic GIT_URL_DISPLAYED_IN_THE_CONSOLE

Commit your changes and push them to the bolt remote:

git add .
git commit -m "serverless initialized"
git push bolt main

The deployment process will start automatically. You can check the status of the deployment in the Boltic console. If everything goes well, the deployment will finish successfully in a few minutes. You can also check the logs to see the if there are any errors. Once the deployment is finished, you can access your app through the URL provided in the Boltic console.

info

The URL will be in the format https://<region>.api.boltic.io/apps/<system-version>/<org-id>/<app-id>.

Run a Function​

In this guide we recreate and deploy this sample java function to demonstrate how easy it is to setup serverless Java functions on Boltic!

tip

You can follow the guide to recreate the app or just git clone https://github.com/bolticio/serverless-samples.git to get a local copy.

Make sure to navigate to appropriate directory using: cd serverless-samples/java/functions/docker/hello-world

note

Currently there is not native way to test serverless functions locally. You can test the function by directly deploying it to Boltic.

We assume you already have Java installed.

Create the Function​

The hello-world application is, as you’d expect for an example, very minimal.

Create a new file src/main/java/com/boltic/io/serverless/Handler.java and add the following code:

Note

For Java, all serverless files should be in the src/main/java/com/boltic/io/serverless/ directory and the package name should be com.boltic.io.serverless.

// src/main/java/com/boltic/io/serverless/Handler.java
package com.boltic.io.serverless;

import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

@Service
public class Handler {
    public ResponseEntity<String> handle() {
        try {
            // Prepare the response JSON
            String responseJson = "{\"message\": \"Hello World\"}";
            return ResponseEntity.ok().body(responseJson);
        } catch (Exception e) {
            // Handle errors
            e.printStackTrace();
            return ResponseEntity.status(500).body("Internal Server Error");
        }
    }
}

Before Deployment ​

A few more steps are necessary before deploying the function.

The handler will be the entry point for the function. The handler is the function that will be called when the function is invoked. The handler should be in the format module_name.function_name. The module_name is the name of the file where the function is defined and the function_name is the name of the function that will be called. Checkout handler for now information

app: java-buildpack-func-sample
region: asia-south1
handler: "Handler.handler"

build:
  builtin: dockerfile
  ignorefile: .gitignore

Testing the function locally​

To test any boltic serverless function locally please refer boltctl serverless test command.

Deploy to Boltic​

Deployment of the function is similar to deploying an application. You can deploy the function by following the same steps as mentioned in the Deploy to Boltic section.

Congrats! You have successfully built, deployed, and connected to your first Java application/function on Boltic. 🚀