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
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"]
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
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
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
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
Then, apply the Kubernetes manifests:
kubectl apply -f k8s/deployment.yaml
kubectl apply -f k8s/service.yaml
Check the status of your deployment:
kubectl get pods
kubectl get services
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
Example Secret (for sensitive data like passwords):
apiVersion: v1
kind: Secret
metadata:
name: app-secret
type: Opaque
data:
DB_PASSWORD: cGFzc3dvcmQ=
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
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!
📧
🚩
SOCIAL SHARE CARD GENERATOR