Dockerizing Spring Boot and Pushing to Docker Hub via GitHub Actions

Dockerizing your Spring Boot application and automating its deployment to Docker Hub using GitHub Actions is an efficient way to streamline the software development lifecycle. With Docker, you can package your application and its dependencies into a standardized container that can run anywhere. GitHub Actions further enhances this process by automating the build and push steps every time you make changes.

This guide will cover:

• Writing a Dockerfile for your Spring Boot application.
• Creating a GitHub Action to build and push a Docker image.
• Using the docker/build-push-action GitHub Action to streamline the process.
• Setting up GitHub Secrets for secure Docker Hub credential management.

By the end of this tutorial, you’ll have a fully automated pipeline that packages your Spring Boot app into a Docker image and publishes it to Docker Hub.

Why Dockerize Your Spring Boot Application?

Docker containers offer a range of benefits for deploying Spring Boot applications, including:

• Consistency: Docker ensures that your application runs the same regardless of the environment.
• Portability: Containers can be deployed on any machine that has Docker installed.
• Simplified Deployment: Containerizing your app removes the complexities of managing dependencies for each environment.
• Scalability: Applications can be spun up in multiple containers for horizontal scaling.

Integrating this approach with GitHub Actions ensures that every code change gets automatically dockerized and pushed to a container registry like Docker Hub.

Writing a Dockerfile for a Spring Boot Application

A Dockerfile is a text file that contains all the instructions needed to assemble a Docker image. Here’s how to write one for a Spring Boot app.

Example Dockerfile

Below is a simple Dockerfile for a Spring Boot application packaged as a JAR file:

# Use an official OpenJDK base image
FROM openjdk:17-jdk-slim

# Set a working directory
WORKDIR /app

# Copy the Spring Boot JAR file into the container
COPY target/my-spring-boot-app.jar app.jar

# Expose the application port
EXPOSE 8080

# Run the JAR file
ENTRYPOINT ["java", "-jar", "app.jar"]

Explanation

1. Base Image:
   • The openjdk image provides the Java runtime for your Spring Boot app.
   • Use 17-jdk-slim for a lightweight Java 17 runtime.
2. Working Directory:
   • Sets the working directory in the container to /app.
3. Copy JAR File:
   • Copies the my-spring-boot-app.jar file into the container. Adjust the file path to match your build output.
4. Port Exposure:
   • Exposes port 8080, which is typically used by Spring Boot applications.
5. Entry Point:
   • Specifies how to run the application when the container starts.

Build the Docker Image Locally

To verify the Dockerfile, you can build the Docker image locally:

mvn package  # Package the Spring Boot app as a JAR
docker build -t my-dockerhub-username/my-spring-boot-app .

Run the container to test it:

docker run -p 8080:8080 my-dockerhub-username/my-spring-boot-app

Once verified, it’s time to automate this with GitHub Actions!

Creating a GitHub Action to Build and Push Docker Image

Step 1: Set Up Workflow Directory

1. At the root of your repository, create a .github/workflows directory: mkdir -p .github/workflows
2. Add a workflow file named docker-push.yml: touch .github/workflows/docker-push.yml

Step 2: Define the Workflow

Here’s a GitHub Actions workflow that builds and pushes the Docker image to Docker Hub:

name: Build and Push Docker Image

on:
  push:
    branches:
      - main
  tags:
    - "v*" # Trigger on version tags like v1.0.0

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Step 1 - Check out the code
      - name: Checkout code
        uses: actions/checkout@v3

      # Step 2 - Log in to Docker Hub
      - name: Log in to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      # Step 3 - Build and Push Docker Image
      - name: Build and Push
        uses: docker/build-push-action@v4
        with:
          context: .
          file: Dockerfile
          push: true
          tags: my-dockerhub-username/my-spring-boot-app:${{ github.ref_name }}

Workflow Breakdown

1. Trigger Events:
   • The workflow runs when code is pushed to the main branch or when a version tag (e.g., v1.0.0) is created.
2. Check Out Code:
   • Uses actions/checkout to fetch the repository.
3. Docker Hub Login:
   • Uses docker/login-action to authenticate with Docker Hub using credentials stored in secrets.
4. Build and Push:
   • The docker/build-push-action builds the Docker image and pushes it to Docker Hub.
   • The image is tagged with the branch or tag name, ensuring unique, versioned releases.

Using docker/build-push-action

The docker/build-push-action GitHub Action simplifies container builds and deployments.

Key Features

• Builds Docker images directly within GitHub runners.
• Pushes images to Docker registries like Docker Hub, AWS, and Google Container Registry.
• Handles multi-platform builds if needed.

Configuration Options

Here are the most common inputs for docker/build-push-action:

• context: Directory to use for the build context (usually . for the root).
• file: Path to the Dockerfile.
• push: Set to true to push the built image to the container registry.
• tags: Specify one or more tags for the image, such as ${{ secrets.DOCKER_USERNAME }}/my-spring-boot-app:v1.0.0.

Setting Up Secrets for Docker Hub Credentials

Your Docker Hub username and password must be securely stored as GitHub Secrets to avoid exposing sensitive information.

Adding Docker Hub Credentials

1. Go to your GitHub repository.
2. Navigate to Settings → Secrets and variables → Actions.
3. Click New repository secret and add the following:
   • Name: DOCKER_USERNAME, Value: Your Docker Hub username.
   • Name: DOCKER_PASSWORD, Value: Your Docker Hub password.

Benefits of Using GitHub Secrets

• Security: Secrets are encrypted and only accessible to the workflow.
• Automation: Once set up, credentials are automatically used by the workflow without manual intervention.

Full Workflow Example

Here’s the complete workflow to build, tag, and push your Spring Boot Docker image to Docker Hub:

name: Build and Push Docker Image

on:
  push:
    branches:
      - main
  tags:
    - "v*"

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Log in to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Build and Push
        uses: docker/build-push-action@v4
        with:
          context: .
          file: Dockerfile
          push: true
          tags:
            my-dockerhub-username/my-spring-boot-app:${{ github.ref_name }}

Final Thoughts

Dockerizing your Spring Boot application and automating the build-and-push pipeline with GitHub Actions simplifies deployment and ensures consistency across environments. By writing a Dockerfile, leveraging the docker/build-push-action GitHub Action, and securely managing Docker Hub credentials with GitHub Secrets, you can create a robust CI/CD pipeline for your project.

Set up your workflow today and enjoy the benefits of a fully automated Docker deployment process!