DEV Community

Cover image for Deploying Spring Boot Applications to the Cloud: A Beginner's Guide
Igor Venturelli
Igor Venturelli

Posted on • Originally published at igventurelli.io

Deploying Spring Boot Applications to the Cloud: A Beginner's Guide

#spring #beginners #docker #kubernetes

Deploy Spring Boot apps with Docker and Kubernetes! Learn containerization, orchestration, and scaling in this step-by-step guide

Modern software deployment is all about containers and orchestration, and if you’re working with Spring Boot, leveraging Docker and Kubernetes can transform how you manage and scale applications. This beginner-friendly guide explains how to package a Spring Boot application into a Docker container and deploy it to a Kubernetes cluster.

Preparing Your Spring Boot Application for Docker

Docker simplifies packaging your application with its dependencies into a lightweight, portable container. To start, ensure your Spring Boot application is production-ready:

  • Package your application as a JAR file using Maven or Gradle.
  • Externalize configurations for environment-specific flexibility.

Example Maven command to create a JAR:

mvn clean package
Enter fullscreen mode Exit fullscreen mode

Create a Dockerfile to define how the application is built and run:

# Use an OpenJDK base image FROM openjdk:17-jdk-slim # Set the working directory in the container WORKDIR /app # Copy the JAR file into the container COPY target/myapp.jar myapp.jar # Expose the application port EXPOSE 8080 # Command to run the application ENTRYPOINT ["java", "-jar", "myapp.jar"]
Enter fullscreen mode Exit fullscreen mode

Build and run the Docker image:

# Build the Docker image docker build -t my-spring-boot-app . # Run the container docker run -p 8080:8080 my-spring-boot-app
Enter fullscreen mode Exit fullscreen mode

Visit http://localhost:8080 to confirm your application is running.

Deploying to Kubernetes

Kubernetes (K8s) is the go-to platform for orchestrating containerized applications. It automates deployment, scaling, and management of applications.

Start by creating a k8s directory to store your deployment configuration files.

Creating a Deployment Manifest

The Deployment resource ensures that your application is running and manages scaling and updates. Here’s an example YAML file:

apiVersion: apps/v1 kind: Deployment metadata: name: my-spring-boot-app spec: replicas: 3 selector: matchLabels: app: my-spring-boot-app template: metadata: labels: app: my-spring-boot-app spec: containers: - name: my-spring-boot-app image: my-spring-boot-app:latest ports: - containerPort: 8080
Enter fullscreen mode Exit fullscreen mode

Exposing the Application with a Service

To make your application accessible, define a Service:

apiVersion: v1 kind: Service metadata: name: my-spring-boot-app-service spec: type: LoadBalancer selector: app: my-spring-boot-app ports: - protocol: TCP port: 80 targetPort: 8080
Enter fullscreen mode Exit fullscreen mode

Deploying to Kubernetes

First, push your Docker image to a container registry (like Docker Hub):

docker tag my-spring-boot-app <your-dockerhub-username>/my-spring-boot-app:latest docker push <your-dockerhub-username>/my-spring-boot-app:latest
Enter fullscreen mode Exit fullscreen mode

Then, apply the Kubernetes manifests:

kubectl apply -f k8s/deployment.yaml kubectl apply -f k8s/service.yaml
Enter fullscreen mode Exit fullscreen mode

Check the status of your deployment:

kubectl get pods kubectl get services
Enter fullscreen mode Exit fullscreen mode

Once the Service is running, access your application via the external IP provided by the LoadBalancer.

Configuring Environment Variables in Kubernetes

Externalizing configuration is key to keeping your container images environment-agnostic. Use a ConfigMap and a Secret in Kubernetes for this purpose.

Example ConfigMap:

apiVersion: v1 kind: ConfigMap metadata: name: app-config data: SPRING_PROFILES_ACTIVE: prod
Enter fullscreen mode Exit fullscreen mode

Example Secret (for sensitive data like passwords):

apiVersion: v1 kind: Secret metadata: name: app-secret type: Opaque data: DB_PASSWORD: cGFzc3dvcmQ=
Enter fullscreen mode Exit fullscreen mode

Reference these in your deployment manifest:

env: - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: app-config key: SPRING_PROFILES_ACTIVE - name: DB_PASSWORD valueFrom: secretKeyRef: name: app-secret key: DB_PASSWORD
Enter fullscreen mode Exit fullscreen mode

Monitoring and Scaling

Kubernetes provides built-in tools to monitor and scale your application:

  • View logs: kubectl logs <pod-name>
  • Scale replicas: kubectl scale deployment my-spring-boot-app --replicas=5
  • Monitor resources: kubectl top pods

For more advanced monitoring, consider integrating Prometheus and Grafana.

Conclusion

Deploying Spring Boot applications with Docker and Kubernetes simplifies management and scaling, providing flexibility to meet modern application demands. Docker containers encapsulate your application, while Kubernetes ensures high availability and automated scaling. By following this guide, you’ve taken the first step toward mastering containerized Spring Boot deployments. With these tools, your applications are ready to meet the challenges of the cloud era.

Let’s connect!

📧 Don’t Miss a Post! Subscribe to my Newsletter!
➡️ LinkedIn
🚩 Original Post
☕ Buy me a Coffee

Top comments (0)