Deployment Setup for Spring Boot Apps With MongoDB and Kubernetes
In this article, we demonstrate the setup of an AngularAndSpring project to show the development setup with an in-memory MongoDB and Kubernetes setup for deployment. The goal for the development setup is to have a Spring Boot app that can be run without a local MongoDB installation and be developed with fast restarts. The goal for the Deployment Setup is to build a Docker image of the project and to run it in a Kubernetes setup with a MongoDB image to have horizontal scalability of the front-end.
Development Setup
To get the in-memory MongoDB, this profile has to be added to the pom.xml:
<profile>
<id>standalone</id>
<activation>
<property>
<name>docker</name>
<value>!true</value>
</property>
</activation>
<dependencies>
<dependency>
<groupId>de.flapdoodle.embed</groupId>
<artifactId>de.flapdoodle.embed.mongo</artifactId>
</dependency>
</dependencies>
</profile>This profile checks the property 'docker,' and if it not found (the default), it adds the dependency of the embedded MongoDB. The Project can just be started and have a MongoDB available on the development computer.
The property file looks like this:
security.jwt.token.secret-key=secret-key1234567890abcdefg
security.jwt.token.expire-length=86400000
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=testIt sets the default values for MongoDB that will be overwritten in the Deployment Setup.
@Configuration
public class SpringMongoConfig extends AbstractReactiveMongoConfiguration {
private static final Logger log = LoggerFactory.getLogger(ScheduledTask.class);
@Value("${spring.data.mongodb.host}")
private String mongoHost;
@Value("${spring.data.mongodb.port}")
private String mongoPort;
@Value("${spring.data.mongodb.database}")
private String mongoDB;
@Override
protected String getDatabaseName() {
return mongoDB;
}
@Override
public MongoClient reactiveMongoClient() {
String myHost = System.getenv("MONGODB_HOST");
log.info("MONGODB_HOST="+myHost);
return MongoClients.create("mongodb://"+(myHost==null ? mongoHost : myHost)+":"+mongoPort);
}
}In lines 5-12, the config of is read from the application.properties.
In lines 20-24, the environment variable is read and its value used for the host of the MongoDB, if it is set.
In the development setup, the 'MONGODB_HOST' environment variable does not exist and the defaults of the properties file are used. The Kubernetes setup sets the environment variable and the MongoDB of the Kubernetes setup is used.
That is all that is needed for the development setup.
Deployment Setup
To avoid the setup of the AngularAndSpring Project and the MongoDB on the server, Docker images are used. To manage the Docker images, Kubernetes is used. That way, the images can be deployed on a cloud with Kubernetes support, and the stateless frontend is scalable. In this example, the Minikube project is used to have a local Kubernetes distribution on the computer.
Create the Docker image
To create the Docker image, the Maven build has to be executed with the command 'mvn clean install -Ddocker=true.' That activates the following profile:
<profile>
<id>docker</id>
<activation>
<property>
<name>docker</name>
<value>true</value>
</property>
</activation>
<build>
<plugins>
<plugin>
<groupId>com.spotify</groupId>
<artifactId>dockerfile-maven-plugin</artifactId>
<version>1.4.4</version>
<executions>
<execution>
<id>default</id>
<goals>
<goal>build</goal>
<goal>push</goal>
</goals>
</execution>
</executions>
<configuration>
<repository>${docker.image.prefix}/${project.artifactId}</repository>
<tag>${project.version}</tag>
<buildArgs>
<JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
</buildArgs>
</configuration>
</plugin>
</plugins>
</build>
</profile>This profile does not add the in-memory MongoDB and creates the Docker image of the Spring Boot Jar. Then, the image has to be pushed to the Docker Repository, or the image available at the public repo can be used.
The Kubernetes Setup
To set up the Minikube distribution on a computer, there is documentation for the different Operating Systems. You need Minikube and kubectl.
Volume
To persist the data of MongoDB, a Volume is needed. This is kubMongoVolume.yaml.
kind: PersistentVolume
apiVersion: v1
metadata:
name: task-pv-volume
labels:
type: local
spec:
storageClassName: manual
accessModes:
- ReadWriteOnce
capacity:
storage: 1Gi
hostPath:
path: /data/mongo1
type: DirectoryOrCreateThis file sets up a persistent volume to store the data in. The accessMode means it can be used by one user, and the hostPath is set to the /data directory of Minikube that is persisted on the hard disk. The type is needed to create the directory if it does not exist yet.
VolumeClaim
The VolumeClaim requests the storage for MongoDB. The following is kubMongoVolumeClaim.yaml.
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mongo-pv-claim
labels:
app: mongopv
spec:
accessModes:
- ReadWriteOnce
storageClassName: manual
resources:
requests:
storage: 1Gi VolumeClaim requests the storage that was provided by the Volume. There are other types of storage that can be used by more than one VolumeClaim.
MongoDB Deployment
This deployment has the setup for the MongoDB Docker image in Minikube. This is kubMongo.yaml.
apiVersion: apps/v1
kind: Deployment
metadata:
name: mongodb
labels:
appdb: mongodb
spec:
replicas: 1
selector:
matchLabels:
appdb: mongodb
template:
metadata:
labels:
appdb: mongodb
spec:
containers:
- name: mongodb
image: mongo:3.6.6
ports:
- containerPort: 27017
volumeMounts:
- name: hostvol
mountPath: /data/db
volumes:
- name: hostvol
persistentVolumeClaim:
claimName: mongo-pv-claimThe spec has the Docker config for the MongoDB image and the volume of the volume claim.
Line 19 is the Docker image of MongoDB.
Line 21 is the port that is exposed.
Lines 23-24 are the connection of the volume to the image path. The path "/data/db" is the path where MongoDB stores its files, and it is mounted on the persistent volume.
Lines 26-28 are the connection of the volume to the persistent volume claim
MongoDB Service
This service has the setup of the service inside Minikube for MongoDB. This is kubMongoService.yaml.
apiVersion: v1
kind: Service
metadata:
name: mongodb
labels:
app: mongodb
spec:
ports:
- port: 27017
protocol: TCP
selector:
appdb: mongodbThis has the setup to expose the MongoDB service in Minikube.
AngularAndSpring Deployment
This deployment has the setup of the Docker image of AngularAndSpring. This is kubApp.yaml.
apiVersion: apps/v1
kind: Deployment
metadata:
name: angularandspring
labels:
app: angularandspring
spec:
replicas: 1
selector:
matchLabels:
app: angularandspring
template:
metadata:
labels:
app: angularandspring
spec:
containers:
- name: angularandspring
image: angular2guy/angularandspring:latest
env:
- name: MONGODB_HOST
value: mongodb
ports:
- containerPort: 8080The spec part has the setup of the Docker image of AngularAndSpring.
In line 19, there is an image from DockerHub.
In lines 21-22, we see the setting of the "MONGODB_HOST" environment variable to the DNS of the DB. Kubernetes sets the DNS name of the MongoDB deployment to "mongodb" so that the Mongo Path in the Spring Boot configuration works.
In line 24, the HTTP port of the Project is exposed.
AngularAndSpring Service
The service of AngularAndSpring sets up the port of the Project. This is kubAppService.yaml.
apiVersion: v1
kind: Service
metadata:
name: web-service
labels:
run: web-service
spec:
type: NodePort
ports:
- port: 8080
protocol: TCP
selector:
app: angularandspring The spec exposes the port 8080 of the AngularAndSpring deployment.
Run the Setup
To run the setup, the YAML files need to be run with the kubectl command. If a shell is available, this file can be used minikubeSetup.sh.
#!/bin/sh
kubectl create -f ./kubMongoVolume.yaml
kubectl create -f ./kubMongoVolumeClaim.yaml
kubectl create -f ./kubMongo.yaml
kubectl create -f ./kubMongoService.yaml
kubectl create -f ./kubApp.yaml
kubectl create -f ./kubAppService.yaml
kubectl get services
minikube ipFirst, the Minikube has to be started with the command "minikube start." Then, the commands need to be executed. Then, the commands "kubectl get services" and "minikube ip" will show an output like this:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 10d
mongodb ClusterIP 10.109.101.39 <none> 27017/TCP 10d
web-service NodePort 10.105.201.74 <none> 8080:31810/TCP 10d
192.168.99.100To access the AngularAndSpring Project, the URL for the browser is:
http://192.168.99.100:31810/
This represents the IP of line five and the port that is mapped to 8080 of line 4.
The quotes are requested by a timer method. That means the project takes a few seconds to initialize itself and show the first set of quotes.
Conclusion
This setup enables easy development of Spring Boot Apps with reactive features that are available with MongoDB. The deployment setup enables the easy deployment of the AngularAndSpring Project and the MongoDB on a Kubernetes cluster. The front-end is easily scalable. And, because it is stateless, the MongoDB back-end would need a separate setup for further scalability. That makes a deployment in a cloud that supports Kubernetes easy. That way, the reactive features of Spring can be used without the effort of setting up a local DB for development or deployment.
