Awesome Open Source
Awesome Open Source

Build Status

Build and deploy Java Spring Boot microservices on Kubernetes

Read this in other languages: 한국어中国.

Spring Boot is one of the popular Java microservices framework. Spring Cloud has a rich set of well integrated Java libraries to address runtime concerns as part of the Java application stack, and Kubernetes provides a rich featureset to run polyglot microservices. Together these technologies complement each other and make a great platform for Spring Boot applications.

In this code we demonstrate how a simple Spring Boot application can be deployed on top of Kubernetes. This application, Office Space, mimicks the fictitious app idea from Michael Bolton in the movie Office Space. The app takes advantage of a financial program that computes interest for transactions by diverting fractions of a cent that are usually rounded off into a seperate bank account.

The application uses a Java 8/Spring Boot microservice that computes the interest then takes the fraction of the pennies to a database. Another Spring Boot microservice is the notification service. It sends email when the account balance reach more than $50,000. It is triggered by the Spring Boot webserver that computes the interest. The frontend uses a Node.js app that shows the current account balance accumulated by the Spring Boot app. The backend uses a MySQL database to store the account balance.



  1. The Transaction Generator service written in Python simulates transactions and pushes them to the Compute Interest microservice.
  2. The Compute Interest microservice computes the interest and then moves the fraction of pennies to the MySQL database to be stored. The database can be running within a container in the same deployment or on a public cloud such as IBM Cloud.
  3. The Compute Interest microservice then calls the notification service to notify the user if an amount has been deposited in the user’s account.
  4. The Notification service uses IBM Cloud Function to send an email message to the user.
  5. Additionally, an IBM Cloud Function to send messages to Slack can also be invoked.
  6. The user retrieves the account balance by visiting the Node.js web interface.

Included Components

  • IBM Cloud Kubernetes Service: IBM Bluemix Container Service manages highly available apps inside Docker containers and Kubernetes clusters on the IBM Cloud.
  • Compose for MySQL: Probably the most popular open source relational database in the world.
  • IBM Cloud Functions: Execute code on demand in a highly scalable, serverless environment.

Featured Technologies

  • Container Orchestration: Automating the deployment, scaling and management of containerized applications.
  • Databases: Repository for storing and managing collections of data.
  • Serverless: An event-action platform that allows you to execute code in response to an event.



  1. Clone the repo
  2. Create the Database service
  3. Create the Spring Boot Microservices
  4. Use IBM Cloud Functions with Notification service (Optional)
  5. Deploy the Microservices
  6. Access Your Application

1. Clone the repo

Clone this repository. In a terminal, run:

$ git clone

2. Create the Database service

The backend consists of a MySQL database and the Spring Boot app. Each microservice has a Deployment and a Service. The deployment manages the pods started for each microservice. The Service creates a stable DNS entry for each microservice so they can reference their dependencies by name.

  • There are two ways to create the MySQL database backend: Use MySQL in container OR Use IBM Cloud Compose for MySQL

  • Use MySQL in container (Option 1)

$ kubectl create -f account-database.yaml
service "account-database" created
deployment "account-database" created

Default credentials are already encoded in base64 in secrets.yaml.

Encoding in base64 does not encrypt or hide your secrets. Do not put this in your Github.

$ kubectl apply -f secrets.yaml
secret "demo-credentials" created

Continue on in Step 3.

  • Use IBM Cloud Compose for MySQL (Option 2)

Provision IBM Cloud Compose for MySQL. Go to Service credentials and view your credentials. Your MySQL hostname, port, user, and password are under your credential uri and it should look like this images You will need to apply these credentials as a Secret in your Kubernetes cluster. It should be base64 encoded. Use the script ./scripts/ You will be prompted to enter your credentials. This will encode the credentials you input and apply them in your cluster as Secrets.

$ ./scripts/
Enter MySQL username:
Enter MySQL password:
Enter MySQL host:
Enter MySQL port:
secret "demo-credentials" created

You can also use the secrets.yaml file and edit the data values in it to your own base64 encoded credentials. Then do kubectl apply -f secrets.yaml.

3. Create the Spring Boot Microservices

You will need to have Maven installed in your environment. If you want to modify the Spring Boot apps, you will need to do it before building the Java project and the docker image.

The Spring Boot Microservices are the Compute-Interest-API and the Send-Notification.

Compute-Interest-API is a Spring Boot app configured to use a MySQL database. The configuration is located in compute-interest-api/src/main/resources/ in spring.datasource.*

The is configured to use MYSQL_DB_* environment variables. These are defined in the compute-interest-api.yaml file. It is already configured to get the values from the Kubernetes Secrets that was created earlier.

The Send-Notification can be configured to send notification through gmail and/or Slack. The notification is sent when the account balance on the MySQL database goes over $50,000.

  • Build your projects using Maven

After Maven has successfully built the Java project, you will need to build the Docker image using the provided Dockerfile in their respective folders.

Note: The compute-interest-api multiplies the fraction of the pennies to x100,000 for simulation purposes.

Go to containers/compute-interest-api
$ mvn package

Go to containers/send-notification
$ mvn package

  • Build your Docker images for Spring Boot services

Note: This is being pushed in the IBM Cloud Container Registry.

If you plan to use IBM Cloud Container Registry, you will need to setup your account first. Follow the tutorial here.

We will be using IBM Cloud container registry to push images (hence the image naming), but the images can be pushed in Docker hub as well.

$ docker build -t<YOUR_NAMESPACE>/compute-interest-api .
$ docker build -t<YOUR_NAMESPACE>/send-notification .
$ docker push<YOUR_NAMESPACE>/compute-interest-api
$ docker push<YOUR_NAMESPACE>/send-notification
  • Modify compute-interest-api.yaml and send-notification.yaml to use your image

Once you have successfully pushed your images, you will need to modify the yaml files to use your images.

# compute-interest-api.yaml
      - image:<namespace>/compute-interest-api # replace with your image name
# send-notification.yaml
      - image:<namespace>/send-notification # replace with your image name

There are two types of notifications possible, either Using default email service with Notification service or Use IBM Cloud Functions with Notification Service

  • Using default email service (gmail) with Notification service

You will need to modify the environment variables in the send-notification.yaml:

       value: '[email protected]' # change this to the gmail that will send the email
       value: 'password' # change this to the the password of the gmail above
    - name: EMAIL_RECEIVER
       value: '[email protected]' # change this to the email of the receiver

You may now proceed to Step 5 if you don't want to use IBM Cloud Functions.

4. Use IBM Cloud Functions with Notification service

This is an optional step if you want to try IBM Cloud Functions

  • Create Actions The root directory of this repository contains the required code for you to create IBM Cloud Functions. You can create Actions using the ibmcloud wsk or wsk command.

Create action for sending Slack Notification

$ wsk action create sendSlackNotification sendSlack.js --param url --web true
# Replace the url with your Slack team's incoming webhook url.

Create action for sending Gmail Notification

$ wsk action create sendEmailNotification sendEmail.js --web true
  • Test Actions

You can test your IBM Cloud Function Actions using wsk action invoke [action name] [add --param to pass parameters]

Invoke Slack Notification

$ wsk action invoke sendSlackNotification --param text "Hello from OpenWhisk"

Invoke Email Notification

$ wsk action invoke sendEmailNotification --param sender [sender email] --param password [sender password]--param receiver [receiver email] --param subject [Email subject] --param text [Email Body]

You should receive a slack message and receive an email respectively.

  • Create REST API for Actions

You can map REST API endpoints for your created actions using wsk api create. The syntax for it is wsk api create [base-path] [api-path] [verb (GET PUT POST etc)] [action name]

Create endpoint for Slack Notification

$ wsk api create /v1 /slack POST sendSlackNotification

ok: created API /v1/slack POST for action /_/sendEmailNotification

Create endpoint for Gmail Notification

$ wsk api create /v1 /email POST sendEmailNotification
ok: created API /v1/email POST for action /_/sendEmailNotification

You can view a list of your APIs with this command:

$ wsk api list

ok: APIs
Action                                      Verb  API Name  URL
/Anthony.Amanse_dev/sendEmailNotificatio    post       /v1
/Anthony.Amanse_dev/testDefault             post       /v1

Take note of your API URLs. You are going to use them later.

  • Test REST API Url

Test endpoint for Slack Notification. Replace the URL with your own API URL.

$ curl -X POST -H 'Content-type: application/json' -d '{ "text": "Hello from OpenWhisk" }'

Slack Notification

Test endpoint for Gmail Notification. Replace the URL with your own API URL. Replace the value of the parameters sender, password, receiver, subject with your own.

$ curl -X POST -H 'Content-type: application/json' -d '{ "text": "Hello from OpenWhisk", "subject": "Email Notification", "sender": "[email protected]", "password": "passwordOfSender", "receiver": "receiversEmail" }'

Email Notification

  • Add REST API Url to yaml files

Once you have confirmed that your APIs are working, put the URLs in your send-notification.yaml file

  value: '[email protected]' # the sender's email
  value: 'password' # the sender's password
  value: '[email protected]' # the receiver's email
  value: '' # your API endpoint for slack notifications
  value: 'Your balance is over $50,000.00' # your custom message
  value: '' # your API endpoint for email notifications

5. Deploy the Microservices

  • Deploy Spring Boot Microservices
$ kubectl apply -f compute-interest-api.yaml
service "compute-interest-api" created
deployment "compute-interest-api" created
$ kubectl apply -f send-notification.yaml
service "send-notification" created
deployment "send-notification" created
  • Deploy the Frontend service

The UI is a Node.js app serving static files (HTML, CSS, JavaScript) that shows the total account balance.

$ kubectl apply -f account-summary.yaml
service "account-summary" created
deployment "account-summary" created
  • Deploy the Transaction Generator service The transaction generator is a Python app that generates random transactions with accumulated interest.

Create the transaction generator Python app:

$ kubectl apply -f transaction-generator.yaml
service "transaction-generator" created
deployment "transaction-generator" created

6. Access Your Application

You can access your app publicly through your Cluster IP and the NodePort. The NodePort should be 30080.

  • To find your IP:
$ ibmcloud cs workers <cluster-name>
ID                                                 Public IP        Private IP      Machine Type   State    Status   
kube-dal10-paac005a5fa6c44786b5dfb3ed8728548f-w1   free           normal   Ready  
  • To find the NodePort of the account-summary service:
$ kubectl get svc
NAME                    CLUSTER-IP     EXTERNAL-IP   PORT(S)                                                                      AGE
account-summary    <nodes>       80:30080/TCP                                                                 2d
  • On your browser, go to http://<your-cluster-IP>:30080 Account-balance


  • To start over, delete everything: kubectl delete svc,deploy -l app=office-space



This code pattern is licensed under the Apache Software License, Version 2. Separate third party code objects invoked within this code pattern are licensed by their respective providers pursuant to their own separate licenses. Contributions are subject to the Developer Certificate of Origin, Version 1.1 (DCO) and the Apache Software License, Version 2.

Apache Software License (ASL) FAQ

Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
Javascript (1,534,674
Java (697,184
Spring Boot (12,437
Kubernetes (11,889
Microservice (5,982
Serverless (4,849
Containers (3,233
Kubernetes Cluster (622
Openwhisk (194
Ibmcode (162
Ibm Developer Technology Cloud (35
Related Projects