1. Overview
In this article, we’re going to cover setting up a Spring Boot application on Heroku using Spring Cloud Connectors.
Heroku is a service that provides hosting for web services. Also, they provide a large selection of third-party services, called add-ons, that provide everything from system monitoring to database storage.
In addition to all of this, they have a custom CI/CD pipeline that integrates seamlessly into Git that expedites development into production.
Spring supports Heroku through it’s Spring Cloud Connectors library. We’ll be using this to configure a PostgreSQL data source in our application automatically.
Let’s jump into writing the app.
2. Spring Boot Book Service
First, let’s create a new simple Spring Boot service.
3. Heroku Sign Up
Now, we need to sign up for a Heroku account. Let’s go to heroku.com and click on the sign-up button in the top right corner of the page.
Now that we’ve got an account we need to get the CLI tool. We need to navigate to the heroku-cli installation page and install this software. This will give us the tools we need to complete this tutorial.
4. Create Heroku Application
Now that we have the Heroku CLI let’s go back to our app.
4.1. Initialize Git Repository
Heroku works best when using git as our source control.
Let’s begin by going to the root of our application, the same directory as our pom.xml file, and running the command git init to create a git repository. Then run git add . and git commit -m “first commit”.
Now we’ve got our application saved to our local git repository.
4.2. Provision Heroku Web App
Next, let’s use the Heroku CLI to provision a web server on our account.
First, we need to authenticate our Heroku account. From the command line run heroku login and follow the instructions for logging in and creating an SSH key.
Next, run heroku create. This will provision the web server and add a remote repository that we can push our code to for deployments. We’ll also see a domain printed in the console, copy this domain so that we can access it later.
4.3. Push Code to Heroku
Now we’ll use git to push our code to the new Heroku repository.
Run the command git push heroku master to send our code to Heroku.
In the console output we should see logs indicating the upload was successful then their system will, download any dependencies, build our application, run tests (if present), and deploy the app if everything goes smoothly.
That is it -we now have our application publicly deployed to a web server.
5. Test In-Memory on Heroku
Let’s make sure our app is working. Using the domain from our create step, let’s test our live application.
Let’s issue some HTTP requests:
POST https://{heroku-domain}/books HTTP
{"author":"baeldung","title":"Spring Boot on Heroku"}
We should get back:
{
"title": "Spring Boot on Heroku",
"author": "baeldung"
}
Now let’s try to read the object we just created:
GET https://{heroku-domain}/books/1 HTTP
This should return:
{
"id": 1,
"title": "Spring Boot on Heroku",
"author": "baeldung"
}
That all looks good, but in production, we should be using a permanent data store.
Let’s walk through provisioning a PostgreSQL database and configuring our Spring app to use it.
6. Adding PostgreSQL
To add the PostgreSQL database, run this command heroku addons:create heroku-postgresql:hobby-dev
This will provision a database for our web server and add an environment variable that provides the connection information.
Spring Cloud Connector is configured to detect this variable and set up the data source automatically given that Spring can detect that we want to use PostgreSQL.
To let Spring Boot know that we’re using PostgreSQL, we need to make two changes.
First, we need to add a dependency to include the PostgreSQL drivers:
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.2.10</version>
</dependency>
Next, let’s add properties so that Spring Data Connectors can configure the database according to its available resources.
In src/main/resources create an application.properties file and add the following properties:
spring.datasource.driverClassName=org.postgresql.Driver
spring.datasource.maxActive=10
spring.datasource.maxIdle=5
spring.datasource.minIdle=2
spring.datasource.initialSize=5
spring.datasource.removeAbandoned=true
spring.jpa.hibernate.ddl-auto=create
This will pool our database connections and limit our application’s connections. Heroku limits the number of active connections in a development tier database to 10 and so we set our max to 10. Additionally, we set the hibernate.ddl property to create so that our book table will be created automatically.
Finally, commit these changes and run git push heroku master. This will push these changes up to our Heroku app. After our app starts, try running tests from the previous section.
The last thing we need to do is change the ddl setting. Let’s update that value as well:
spring.jpa.hibernate.ddl-auto=update
This will instruct the application to update the schema when changes are made to the entity when the app is restarted. Commit and push this change like before to have the changes pushed to our Heroku app.
We didn’t need to write a custom data source integration for any of this. That’s because Spring Cloud Connectors detects that we’re running with Heroku and using PostgreSQL – and automatically wires up the Heroku data source.
5. Conclusion
We now have a running Spring Boot app in Heroku.
Most of all, the simplicity of going from a single idea to a running application makes Heroku a solid way to deploy.
To find out more about Heroku and all the tools, it offers we can read more on heroku.com.
As always, code snippets can be found over on GitHub.