Getting Started on Heroku Fir with Java (Gradle)

Introduction

Complete this tutorial to deploy a sample Java (Gradle) app to Heroku Private Spaces on the Fir generation of the platform. To deploy the app to the Common Runtime or Cedar Private Spaces, follow this guide instead.

The tutorial assumes that you have:

• A verified Heroku Account
• An existing Fir Private Space
• A team admin or member role that has the app creation permission on the space.
• An SSH key added to your Heroku account
• OpenJDK 17 (or newer) installed locally
• Postgres installed locally

Set Up

Install the Heroku Command Line Interface (CLI). Use the CLI to manage and scale your app, provision add-ons, view your logs, and run your app locally.

Download and run the installer for your platform:

After installation, you can use the heroku command from your command shell.

To log in to the Heroku CLI, use the heroku login command:

$ heroku login
heroku: Press any key to open up the browser to login or q to exit:
Opening browser to https://cli-auth.heroku.com/auth/cli/browser/***
heroku: Waiting for login...
Logging in... done
Logged in as me@example.com

This command opens your web browser to the Heroku login page. If your browser is already logged in to Heroku, click the Log In button on the page.

This authentication is required for the heroku and git commands to work correctly.

If you have any problems installing or using the Heroku CLI, see the main Heroku CLI article for advice and troubleshooting steps.

Clone the Sample App

Clone the sample application to get a local version of the code. Execute these commands in your local command shell or terminal:

$ git clone https://github.com/heroku/gradle-getting-started
$ cd gradle-getting-started

You now have a functioning Git repository that contains a simple application. It includes a build.gradle.kts file, which is used by Gradle, a Java build tool.

Define a Procfile

Use a Procfile, a text file in the root directory of your application, to explicitly declare what command to execute to start your app.

The Procfile in the example app looks like this:

web: java -jar build/libs/java-getting-started-gradle-1.0.0-SNAPSHOT.jar

This Procfile declares a single process type, web, and the command needed to run it. The name web is important here. It declares that this process type is attached to Heroku’s HTTP routing stack and receives web traffic when deployed.

A Procfile can contain additional process types. For example, you can declare a background worker process that processes items off a queue.

Create Your App in a Fir Space

 

Create an app on Heroku to prepare the platform to receive your source code by replacing <space-name> with the name of your Fir space in the command below:

$ heroku create --space <space-name>
Creating app in space <space name>...
Creating app in space <space name>... done, intense-temple-03098
http://intense-temple-03098-e86a12beda0c.cherry-virginia.herokuapp.com/ | https://git.heroku.com/intense-temple-03098.git

When you create an app, a Git remote called heroku also gets created and associated with your local Git repository. Git remotes are versions of your repository that live on other servers. You deploy your app by pushing its code to that special Heroku-hosted remote associated with your app.

Heroku generates a random name for your app, in this case, intense-temple-03098. You can specify your own app name.

Provision a Database

The sample app requires a database. Provision a Heroku Postgres database, an add-on available through the Elements Marketplace. Add-ons are cloud services that provide out-of-the-box additional services for your application, such as logging, monitoring, databases, and more.

$ heroku addons:create heroku-postgresql:essential-0
Creating heroku-postgresql:essential-0 on intense-temple-03098...
Creating heroku-postgresql:essential-0 on intense-temple-03098... ~$0.007/hour (max $5/month)
Database should be available soon
postgresql-adjacent-78684 is being created in the background. The app will restart when complete...
Use heroku addons:info postgresql-adjacent-78684 to check creation progress
Use heroku addons:docs heroku-postgresql to view documentation

You can wait for the database to provision by running this command:

$ heroku pg:wait
Waiting for database postgresql-adjacent-78684... Provisioning
Waiting for database postgresql-adjacent-78684... Available

After that command exits, your Heroku app can access the Postgres database. The DATABASE_URL environment variable stores your credentials. For applications that use the JVM an additional environment variable JDBC_DATABASE_URL is available. It contains a JDBC compatible connection string. You can see all the add-ons provisioned with the addons command:

$ heroku addons

 Add-on                                        Plan        Price        Max price State
 ───────────────────────────────────────────── ─────────── ──────────── ───────── ───────
 heroku-postgresql (postgresql-adjacent-78684) essential-0 ~$0.007/hour $5/month  created
  └─ as DATABASE

The table above shows add-ons and the attachments to the current app (intense-temple-03098) or other apps.

Deploy the App

Deploy your code. This command pushes the main branch of the sample repo to your heroku remote, which then deploys to Heroku:

$ git push heroku main
remote: Updated 24 paths from 1982ddc
remote: Compressing source files... done.
remote: Building source:
remote: Heroku Labs: Build Time Config Vars are *not enabled*.
remote: By default, your config vars are only available at runtime. See https://devcenter.heroku.com/build-time-config-vars for details on Build Time Config Vars.
remote: Extracting source
remote: Image with name "intense-temple-03098/builds" not found
remote: 3 of 4 buildpacks participating
remote: heroku/jvm      6.2.1
remote: heroku/gradle   6.2.1
remote: heroku/procfile 4.2.1
remote:
remote: ## Heroku OpenJDK Buildpack
remote:
remote: - OpenJDK version resolution
remote:   - Using version string provided in `system.properties`
remote:   - Selected major version `17` resolves to `17.0.15`
remote: - OpenJDK Installation
remote:   - Downloading and unpacking OpenJDK distribution
remote:   - Done (2.1s)
remote: - Applying JDK overlay
remote:   - Skipping (directory `.jdk-overlay` not present)
remote: - Linking base image certificates as OpenJDK keystore
remote:   - Done
remote: - Done (finished in 2.1s)
remote:
remote: ## Heroku Gradle Buildpack
remote:
remote: - Running Gradle build
remote:   - Starting Gradle daemon
remote:
remote:       Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
remote:       Downloading https://services.gradle.org/distributions/gradle-8.12-bin.zip
remote:       .............10%.............20%.............30%.............40%.............50%.............60%.............70%.............80%.............90%.............100%
remote:       Starting a Gradle Daemon (subsequent builds will be faster)
remote:       > Task :heroku_buildpack_start_daemon UP-TO-DATE
remote:
remote:       BUILD SUCCESSFUL in 39s
remote:
remote:   - Done (39.5s)
remote:   - Querying tasks
remote:   - Done (2.0s)
remote:   - Querying dependency report
remote:   - Done (4.6s)
remote:   - Running `./gradlew build -x check`
remote:
remote:       Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
remote:       > Task :compileJava
remote:       > Task :processResources
remote:       > Task :classes
remote:       > Task :resolveMainClassName
remote:       > Task :bootJar
remote:       > Task :jar
remote:       > Task :assemble
remote:       > Task :build
remote:
remote:       BUILD SUCCESSFUL in 9s
remote:       5 actionable tasks: 5 executed
remote:
remote:   - Done (9.8s)
remote: - Done (finished in 57.1s)
remote:
remote: ## Procfile Buildpack
remote:
remote: - Processes from `Procfile`
remote:   - web: `java -jar build/libs/java-getting-started-gradle-1.0.0-SNAPSHOT.jar`
remote: - Done (finished in < 0.1s)
remote: Adding layer 'heroku/jvm:openjdk'
remote: Adding layer 'heroku/jvm:runtime'
remote: Adding layer 'heroku/gradle:home'
remote: Adding layer 'buildpacksio/lifecycle:launch.sbom'
remote: Added 1/1 app layer(s)
remote: Adding layer 'buildpacksio/lifecycle:launcher'
remote: Adding layer 'buildpacksio/lifecycle:config'
remote: Adding layer 'buildpacksio/lifecycle:process-types'
remote: Adding label 'io.buildpacks.lifecycle.metadata'
remote: Adding label 'io.buildpacks.build.metadata'
remote: Adding label 'io.buildpacks.project.metadata'
remote: Setting default process type 'web'
remote: Saving intense-temple-03098/builds...
remote: *** Images (sha256:5de6c29f5a73bd1b0655f486c8a71968dfb7aea8e12f82fe6f152ae83d8cd2a0):
remote:       intense-temple-03098/builds:1e8f0657-3e87-4768-95d7-700d5b27e690
remote: Adding cache layer 'heroku/jvm:openjdk'
remote: Adding cache layer 'heroku/gradle:home'
remote: Uploading cache
remote: Launching...
remote: https://intense-temple-03098-e86a12beda0c.cherry-virginia.herokuapp.com/ deployed to Heroku
remote: Verifying deploy... done.
To https://git.heroku.com/intense-temple-03098.git
 * [new branch]      main -> main

The app is now deployed. The default dyno size for Fir Private Spaces is dyno-1c-0.5gb.

Visit the app at the URL shown in the logs. As a shortcut, you can also open the website as follows:

$ heroku open

View Logs

Heroku treats logs as streams of time-ordered events, aggregated from the output streams of all your app and Heroku components. Heroku provides a single stream for all events. View information about your running app by using one of the logging commands:

$ heroku logs
Fetching logs...

2025-04-28T21:53:09.559216+00:00 heroku-router[web]: at=info method=GET path="/" host=intense-temple-03098-e86a12beda0c.cherry-virginia.herokuapp.com request_id=3a48fc1b-fe4c-70c4-d513-7881c4020a47 fwd="123.456.789.0" dyno=web-78698b78cf-8nw42 connect=2ms service=5ms status=200 bytes=10069 protocol=http tls_version=tls1.3

To generate more log messages, refresh the app in your browser.

To stop streaming the logs, press Ctrl+C.

Declare App Dependencies

Heroku recognizes an app as a Java (Gradle) app by the existence of a build.gradle.kts or build.gradle file in the root directory.

The demo app you deployed already has a build.gradle.kts:

plugins {
    java
    id("org.springframework.boot") version "3.4.1"
    id("io.spring.dependency-management") version "1.1.7"
}

group = "com.heroku"
version = "1.0.0-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_17

repositories {
...

The build.gradle.kts file specifies the dependencies to install with your application.

Run ./gradlew build in your local directory to install the dependencies, preparing your system for running the app locally:

$ ./gradlew build
Starting a Gradle Daemon (subsequent builds will be faster)
> Task :compileJava
> Task :processResources
> Task :classes
> Task :resolveMainClassName

Push Local Changes

In this step, you propagate a local change to the application to Heroku.

Modify build.gradle.kts to include an additional dependency for the jscience.

In file build.gradle.kts, on line 16 add:

implementation("org.jscience:jscience:4.3.1")

Add the import statements for the library.

In file src/main/java/com/heroku/java/GettingStartedApplication.java, on line 2 add:

import org.jscience.physics.amount.Amount;
import org.jscience.physics.model.RelativisticModel;
import javax.measure.unit.SI;

Add a new convert method.

In file src/main/java/com/heroku/java/GettingStartedApplication.java, on line 26 add:

@GetMapping("/convert")
String convert(Map<String, Object> model) {
    RelativisticModel.select();
    var energy = Amount.valueOf("12 GeV");

    model.put("result", "E=mc^2: " + energy + " = " + energy.to(SI.KILOGRAM));
    return "convert";
}

Add a new template.

In file src/main/resources/templates/convert.html write:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{fragments/layout :: layout (~{::body},'hello')}">
<body>

<div class="container">
    <p th:text="${result}"/>
</div>

</body>
</html>

Now test locally:

$ ./gradlew build
$ heroku local --port=5006

Visit your application’s /convert path at http://localhost:5006/convert. If your changes worked, you see scientific conversions:

E=mc^2: 12 GeV = (2.139194076302506E-26 ± 1.4E-42) kg

Now deploy this local change to Heroku.

Almost every deploy to Heroku follows this same pattern. First, add the modified files to the local Git repository:

$ git add .

Now commit the changes to the repository:

$ git commit -m "Add convert endpoint"
[main a35289b] Add convert endpoint
 3 files changed, 22 insertions(+)
 create mode 100644 src/main/resources/templates/convert.html

Now deploy as before:

$ git push heroku main

Finally, check that everything is working:

$ heroku open /convert

Debugging

The Heroku Java Cloud Native Buildpack (CNB) turns your code into an Open Container Initiative (OCI) container image when you deploy to Fir. This image gets executed on our dynos.

You can use this image locally to reproduce and debug deployment problems. Build an OCI image from your application to debug locally by using the Heroku Java CNB. If you’re interested, check out the Java CNB tutorial.

Start a One-off Dyno

The heroku run command to launch an interactive one-off dyno is unavailable for Fir. As an alternative, use heroku run:inside to access a running dyno until we add heroku run for Fir.

To execute the command you need the name of a currently running process. You can see a list with heroku ps:

$ heroku ps
=== web (dyno-1c-0.5gb): java -jar build/libs/java-getting-started-gradle-1.0.0-SNAPSHOT.jar (1)

web-78698b78cf-8nw42: up 2025/04/28 16:52:52 -0500 (~ 31s ago)

Use that dyno name to run a command like java -version:

$ heroku run:inside web-78698b78cf-8nw42 "java -version"
Running launcher java -version on ⬢ intense-temple-03098... up, web-78698b78cf-8nw42
Picked up JAVA_TOOL_OPTIONS: -Xmx300m -Xss512k -XX:CICompilerCount=2 -Dfile.encoding=UTF-8
openjdk version "17.0.12" 2024-07-16 LTS
OpenJDK Runtime Environment Zulu17.52+17-CA (build 17.0.12+7-LTS)
OpenJDK 64-Bit Server VM Zulu17.52+17-CA (build 17.0.12+7-LTS, mixed mode, sharing)

Let’s try another example. Create another one-off process within your running dyno and run the bash command to open up a shell on that dyno. You can then execute commands there.

$ heroku run:inside web-78698b78cf-8nw42 "bash"
Running launcher bash on intense-temple-03098...
Running launcher bash on intense-temple-03098... up, web-78698b78cf-8nw42
heroku@web-78698b78cf-8nw42:/workspace$ ls -lah
total 68K
drwxrwsrwx. 7 heroku heroku  16K Jan  1  1980 .
drwxr-xr-x. 1 root   root     28 Apr 28 21:52 ..
-rw-r--r--. 1 heroku heroku   14 Jan  1  1980 .env
drwxr-xr-x. 2 heroku heroku   46 Jan  1  1980 .github
-rw-r--r--. 1 heroku heroku  323 Jan  1  1980 .gitignore
drwxr-sr-x. 5 heroku heroku   57 Jan  1  1980 .gradle
-rw-r--r--. 1 heroku heroku 1.1K Jan  1  1980 LICENSE
-rw-r--r--. 1 heroku heroku   73 Jan  1  1980 Procfile
-rw-r--r--. 1 heroku heroku 2.5K Jan  1  1980 README.md
-rw-r--r--. 1 heroku heroku  155 Jan  1  1980 app.json
drwxr-sr-x. 7 heroku heroku  107 Jan  1  1980 build
-rw-r--r--. 1 heroku heroku  619 Jan  1  1980 build.gradle.kts
drwxr-xr-x. 3 heroku heroku   21 Jan  1  1980 gradle
-rwxr-xr-x. 1 heroku heroku 8.3K Jan  1  1980 gradlew
-rw-r--r--. 1 heroku heroku 2.9K Jan  1  1980 gradlew.bat
-rw-r--r--. 1 heroku heroku   49 Jan  1  1980 settings.gradle.kts
drwxr-xr-x. 3 heroku heroku   18 Jan  1  1980 src
-rw-r--r--. 1 heroku heroku  103 Jan  1  1980 system.properties
heroku@web-78698b78cf-8nw42:/workspace$ exit
exit

Type exit to exit the shell.

Define Config Vars

Heroku lets you externalize configuration by storing data such as encryption keys or external resource addresses in config vars.

At runtime, we expose config vars as environment variables to the application.

For example, modify GettingStartedApplication.java so that the method obtains an energy value from the ENERGY environment variable:

@GetMapping("/convert")
String convert(Map<String, Object> model) {
    RelativisticModel.select();

    final var result = java.util.Optional
        .ofNullable(System.getenv().get("ENERGY"))
        .map(Amount::valueOf)
        .map(energy -> "E=mc^2: " + energy + " = " + energy.to(SI.KILOGRAM))
        .orElse("ENERGY environment variable is not set!");

    model.put("result", result);
    return "convert";
}

The heroku local command automatically sets up the environment based on the contents of the .env file in your local directory. In the top level directory of your sample project, there’s already a .env file that contains:

ENERGY=20 GeV

Rebuild the app with ./gradlew build. Then run the app with heroku local --port=5006 and visit http://localhost:5006/convert to see the conversion value for 20 GeV.

To set the config var on Heroku, execute the following:

$ heroku config:set ENERGY="20 GeV"
Setting ENERGY and restarting intense-temple-03098...
Setting ENERGY and restarting intense-temple-03098... done, v5
ENERGY: 20 GeV

View the app’s config vars using heroku config:

$ heroku config
ENERGY: 20 GeV
...

To see this change in action, deploy your changed application to Heroku.

Use a Database

Listing the config vars for your app displays the URL that your app uses to connect to the database, DATABASE_URL:

$ heroku config
DATABASE_URL:                postgres://xx:yyy@host:5432/d8slm9t7b5mjnd
HEROKU_POSTGRESQL_BROWN_URL: postgres://xx:yyy@host:5432/d8slm9t7b5mjnd
...

Heroku also provides a pg command that shows a lot more information:

$ heroku pg
=== DATABASE_URL

Plan:                  essential-0
Status:                Available
Connections:           unknown/20
PG Version:            16.4
Created:               2025-04-28 21:47
Data Size:             unknown usage / 1 GB (In compliance)
Tables:                0/4000 (In compliance)
Fork/Follow:           Unsupported
Rollback:              Unsupported
Continuous Protection: Off
Add-on:                postgresql-adjacent-78684

The example app you deployed already has database functionality. You can visit the page by appending /database to your app’s URL.

Database Output

* Read from DB: 2024-11-27 13:07:53.002632
* Read from DB: 2024-11-27 13:07:54.965283
* Read from DB: 2024-11-27 13:07:55.620596

If you have Postgres installed locally, you can also interact directly with the database. For example, here’s how to connect to the database using psql and execute a query:

$ heroku pg:psql -c "SELECT * FROM ticks"
--> Connecting to postgresql-adjacent-78684
            tick
----------------------------
 2025-04-28 21:56:13.323436
 2025-04-28 21:56:14.773318
 2025-04-28 21:56:15.585045
(3 rows)

Read more about Heroku PostgreSQL.

Delete Your App

Remove the app from your account. We only charge you for the resources you used.

$ heroku apps:destroy

You can confirm that your app is gone with this command:

$ heroku apps --all

Next Steps

You now know how to configure and deploy a Java app, view logs, and start a console.

To learn more, see:

• How Heroku Works
• Preparing a Codebase for Heroku Deployment
• Heroku Java Documentation