How to Deploy a Spring Boot App with Docker to DigitalOcean App Platform

Learn how to deploy a Spring Boot App with Docker to the DigitalOcean app platform. Our DigitalOcean Support team is here to help you with your questions and concerns.

How to Deploy a Spring Boot App with Docker to DigitalOcean App Platform

DigitalOcean App Platform is a Platform-as-a-Service that enables developers to deploy applications directly to DigitalOcean servers without managing the underlying infrastructure.

Today, our Experts will walk you through deploying a Spring Boot application on the DigitalOcean App Platform via Docker.

Step-by-Step Guide

1. Create a Spring Boot Application

1. Start by initializing a new Spring Boot project using the Spring Boot CLI:

   spring init --build=maven --java-version=17 --dependencies=web,data-jpa,postgresql spring-boot-dockerCopy Code

   This command creates a `spring-boot-docker` directory containing a Maven-based Spring Boot project.
2. List the available dependencies with:

   spring init –listCopy Code
3. Go to the project directory:

   cd spring-boot-dockerCopy Code
4. Next, add a Java class to manage data storage using Spring Data JPA.

2. Add Model Class

1. Go to the package directory:

   cd src/main/java/com/example/springbootdockerCopy Code
2. Then, create and open the `Message.java` file:

   
   touch Message.java
   nano Message.java
   Copy Code
3. Define a `Message` class with fields for ID and message body. This class will map to the PostgreSQL database.

3. Add Repository Layer

1. Create and open the `MessageRepository.java` file:

   
   touch MessageRepository.java
   nano MessageRepository.java
   Copy Code
2. Define the `MessageRepository` interface, extending `JpaRepository` to enable CRUD operations on the `Message` entity.

4. Add Controller Layer

1. Create and open the `MessageController.java` file:

   
   touch MessageController.java
   nano MessageController.java
   Copy Code
2. Define the `MessageController` class to expose RESTful endpoints for saving and retrieving messages.

5. Configure PostgreSQL Database

1. Go to the `resources` directory:

   cd src/main/resourcesCopy Code
2. Open the `application.properties` file:

   nano application.propertiesCopy Code
3. Add the following database configuration:

   spring.datasource.url=jdbc:postgresql://localhost:5432/dbcreds
   spring.datasource.username=dbcreds
   spring.datasource.password=dbcreds
   spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
   spring.jpa.hibernate.ddl-auto=update
   spring.jpa.show-sql=true
   Copy Code

   Replace `

   dbcredsCopy Code

   ` with the actual database credentials.

6. Test Spring Boot App Locally

1. Run the application:

   mvn spring-boot:runCopy Code
2. Test the API using `curl`:

   
   curl -X POST http://localhost:8080/message -H 'Content-Type: application/json' -d '{"body":"Hello world"}'
   curl -X GET http://localhost:8080/message/1
   Copy Code

7. Add a Dockerfile

1. Create and open a `Dockerfile` in the project root:

   
   touch Dockerfile
   nano Dockerfile
   Copy Code
2. Add the following content:

   
   FROM eclipse-temurin:11-jdk-jammy as builder
   WORKDIR /opt/app
   COPY .mvn/ .mvn
   COPY mvnw pom.xml ./
   RUN ./mvnw dependency:go-offline
   COPY ./src ./src
   RUN ./mvnw clean install -DskipTests
   FROM eclipse-temurin:11-jre-jammy
   WORKDIR /opt/app
   EXPOSE 8080
   COPY --from=builder /opt/app/target/*.jar /opt/app/*.jar
   ENTRYPOINT ["java","-Dspring.profiles.active=prod", "-jar", "/opt/app/*.jar"]
   Copy Code

8. Build Docker Image

Ensure Docker is running and build the image:

docker build -t spring-boot-docker .Copy Code

9. Push Code to GitHub

Initialize a Git repository and push the code:

git init
git remote add origin https://github.com/your_name/spring-boot-docker
git branch -M main
git add .
git commit -m "Initial commit"
git push -u origin main
Copy Code

10. Deploy to DigitalOcean App Platform

1. Log in to the DigitalOcean account.
2. Click Create and select Apps.
3. Link the GitHub repository and select `spring-boot-docker`.
4. DigitalOcean detects the `Dockerfile`; click Next.
5. Configure environment variables if needed and deploy the application.

11. Attach a PostgreSQL Database

1. Click Create > Database and select PostgreSQL.
2. Add the database credentials as environment variables:

   
   SPRING_DATASOURCE_URL=jdbc:postgresql://:/?sslmode=require
   SPRING_DATASOURCE_USERNAME=
   SPRING_DATASOURCE_PASSWORD=
   Copy Code
3. Save changes to trigger a redeployment.

12. Test the Live Application

Retrieve the live app URL from DigitalOcean and test the API:

curl -X POST https://your-app-url/message -H 'Content-Type: application/json' -d '{"body":"Hello world"}'
curl -X GET https://your-app-url/message/1
Copy Code

The Spring Boot application is now successfully deployed on the DigitalOcean App Platform!

[Need assistance with a different issue? Our team is available 24/7.]

Conclusion

With the above best practices and troubleshooting methods, developers can easily resolve the “Failed: error occurred while running build command” issue in Cloudflare Pages.

In brief, our Support Experts demonstrated how to deploy a Spring Boot App with Docker to the DigitalOcean app platform.