Deploying Spring Boot Application on CapRover Using GitHub Actions

In this blog post, I will explain how we can deploy the Spring Boot application on CapRover using GitHub Actions.

In my previous blog post, I have shown how you can deploy Spring Boot application from GitHub repo automatically when ever we push the new code. In the deployment method we were building docker image in CapRover server, while the process is simple , it may not work on server with low amount of RAM as build process may require more RAM than available in the Server.

In this blog post, I will show how to deploy Spring Boot application on CapRover using GitHub Action, where we build the docker image and deploy the application.

We use the CapRover CLI deployment method from GitHub to deploy the application using GitHub Actions.

What is GitHub Actions

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline. You can create workflows that build and test every pull request to your repository, or deploy merged pull requests to production.

For deploying application using CapRove CLI method via GitHub Action, we need to prepare the environment.

Database SetUp

Let’s first setup “PostgreSQL” database server to store the data. We can setup PostgreSQL Database with Caprover one click app.

Please refer to the my previous blog post to setup database server and create database for the application.

Creating Application

Log into CapRover server and create a new application.

To deploy the application from GitHub Actions, we need to login into the server. So instead of using the password we generate the app specific token which can be used as password to deploy the application.

Click on the application on dashboard and go to the “Deployment” section.

Go to the “Method 1: Official CLI” section and click on the “Enable App Token” button to generate token. Please note down the generated token.

Setting Environment Variables and PortMapping

We need to setup the environment variables in “App Config” section , so that application points to installed database.

SPRING_DATASOURCE_URL : jdbc:postgresql://srv-captain--postgres:5432/eisCode language: Java (java)

Click on “Save & Update” button to save the configuration.

I have configured to application to run on port 80, so I am not configuring ports.

As the spring boot application runs on port 8080 , so you should map container port 8080 to container port of your choice.

Generating Docker Token

Using GitHub action we going to generate the docker image and push it to docker registry before deploying it on CapRover server. To push docker image into docker registry we need to login from GitHub action. To login into docker registry, we generate the docker token which acts as password.

Log into hub.docker.com

Open your account settings by clicking on <user-name>/Account settings.

Click on “Security” link on the left side menu.

Generate new token by clicking on the “New Access Token” button

Note down the access token.

Creating GitHub Secrets

GitHub actions file is publicly accessible, so we can not store sensitive information in the actions file. Secrets are encrypted variables that we create in repository, or repository environment.

  1. On GitHub.com, navigate to the main page of the repository.
  2. Under repository name, click  Settings.

3.In the “Security” section of the sidebar, select  Secrets and variables, then click Actions.

4.Click the Secrets tab.

5.Click New repository secret.

6.Click New repository secret.

7.Type a name for your secret in the Name input box.

8.Enter the value for your secret

9.Click Add secret

We have to store all the sensitive information in secrets. We are going to create following secrets.


Creating Action Files

Next we create action file which contains the work flow steps.

Create .github/workflows directory in root of your projects.

inside workflows folder create “deployment.yml” file and place following code.

name: Deploy APP

  IMAGE_NAME: sureshgkhyd/springboot-caprover-deployment2
  DOCKERFILE: Dockerfile.caprover
  CAPROVER_APP: springboot-caprover-deployment2
  DOCKER_REGISTRY: docker.io

    branches: [ "master" ]
    branches: [ "master" ]

    runs-on: ubuntu-latest
      - uses: actions/checkout@v3
      - run: |
      - name: Login to Docker Hub
        uses:  docker/login-action@v2
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_TOKEN }}
      - name: Setup Docker buildx
        uses: docker/setup-buildx-action@v2
      - name: Build and Push Release to DockerHub
        shell: bash
        run: ./build_and_push.sh
      - name: Deploy to CapRover
        uses: caprover/deploy-from-github@d76580d79952f6841c453bb3ed37ef452b19752c
          server: "${{ secrets.CAPROVER_SERVER }}"
          app: ${{ env.CAPROVER_APP }}
          token: "${{ secrets.APP_TOKEN }}"
          image: "${{ env.FULL_IMAGE_NAME }}"Code language: Java (java)

Here is explanation of each action

 - uses: actions/checkout@v3Code language: Java (java)

It checks out the application code

uses:  docker/login-action@v2Code language: Java (java)

Log into docker registry to upload docker image.

uses: docker/setup-buildx-action@v2Code language: Java (java)

Setup docker to use buildx command.

As my CapRover instance is deployed on ARM based computer, I am using docker buildx to create ARM based image for deployment.

If you have created CapRover instance on x86_64 based computer, you can omit this action.

uses: caprover/deploy-from-github@d76580d79952f6841c453bb3ed37ef452b19752cCode language: Java (java)

Deploys the docker image to CapRover instance

I have created a script file which builds and pushes docker image to docker hub which is invoked as part GitHub action workflow.



# Exit early if any command fails
set -e

# ensure you're not running it on local machine
if [ -z "$CI" ] || [ -z "$GITHUB_REF" ]; then
    echo "Running on a local machine! Exiting!"
    exit 127
    echo "Running on CI"

# dump all env vars in a temp file and pass it as build args
rm /tmp/build_args || echo OK
env > /tmp/build_args
echo "--build-arg \""`cat /tmp/build_args | sed -z 's/\n/" --build-arg "/g'`"IGNORE_VAR=IGNORE_VAR\"" >  /tmp/build_args

BUILD_ARGS=`cat /tmp/build_args`
COMMAND="docker buildx  build  --platform linux/amd64,linux/arm64 --push -t $FULL_IMAGE_NAME -t $IMAGE_NAME_WITH_REGISTRY:latest -f $DOCKERFILE $BUILD_ARGS --no-cache ."

echo "-------------------"
echo "-------------------"
echo "-------------------"
echo "-------------------"
echo "-------------------"

/bin/bash -c "$COMMAND"

rm /tmp/build_argsCode language: Java (java)

We need to set execution mode permission for the script file as we are using Ubuntu to run our GitHub actions.

In Linux

chmod +x build_andpush.shCode language: Java (java)

In Windows

Open GitBash window and execute following command.

git update-index --chmod=+xCode language: Java (java)

Following is the Docker file which is referenced in script file


FROM adoptopenjdk/openjdk11:jdk- as build
COPY mvnw ./
COPY .mvn .mvn
COPY pom.xml ./
COPY src src
RUN chmod a+rx mvnw
RUN ./mvnw clean package -DskipTests

FROM adoptopenjdk/openjdk11:jdk-
COPY --from=build "./target/*.jar" /app.jar
RUN addgroup --system springboot && adduser --system sbuser && adduser sbuser springboot
USER sbuser
ENTRYPOINT ["java", "-jar", "/app.jar"]Code language: Java (java)

When you push new code to master branch, GitHub will automatically trigger the workflow from actions and build and deploy the application.

Testing the application.

Now we can test our application with rest client.

You might be also interested in



Similar Posts