How to deploy java application in a cloud instance from the scratch to an advanced architecture?

Question

I need to deploy my spring-boot application on compute engine in Google cloud platform. I have already created an instance and through SSH Apache and Maven have been installed. Further, war file has been uploaded into the bucket. Anybody can provide me with the remaining commands to deploy the war file on tomcat instance or any other cloud platforms with linux?

Thanks

Answer 1

Deploy in compute engine instance of google not substantially different from AWS, Azure or another linux host provider.

You just need an ssh connection to the remote machine and install the required software to compile, build, zip, deploy, etc

I will list some approaches from basic(manually) to advanced(automated):

#1 Bash scripting

• unzip and configure git
• unzip and configure java
• unzip and configure maven
• unzip and configure tomcat (this is not required if spring-boot is used)
• configure the linux host to open 8080 port
• create a script called /devops/pipeline.sh in your remote cloud linux instance, with the following steps

For war deployment :

# get the source code
cd /tmp/folder/3dac58b7
git clone http://github.com/myrepo.git .
# create war
mvn clean package
# move war to deploy tomcat folder
cp target/my_app.war /my/tomcat/webapps
# stop tomcat
bash /my/tomcat/shutdown.sh
# start tomcat
bash /my/tomcat/startup.sh

Or spring-boot startup

# get the source code
cd /tmp/folder/3dac58b7
git clone http://github.com/myrepo.git .
# create jar
mvn clean package
# kill or stop the application
killall java
# start the application
java $JAVA_OPTS -jar $jar_file_name

• After push to git, just connect to you instance using ssh and execute

bash /devops/pipeline.sh

Improvements: Parametrize repository name, branch name, mvn profile, database credentials, create a tmp/uuid folder in every execution, delete the tmp/uuid after deploy,optimize start and stop of application using pid, etc

#2 Docker

• Install docker in your remote cloud linux instance

• Create a Dockerfile with all the steps for war or springboot (approach #1) and store it close to your source code (I mean in your git repository)

• Perform a git push of your changes

• Connect to your remote cloud linux instance using ssh:

• Build your docker image: docker build ...

• Delete previous container and run a new version:

  docker rm my_app -f docker run -d --name my_app -p 8080:8080 my-container-name

---

In the previous approaches, build operations are performed in the remote server. To do that, several tools are needed in that server. In the following approaches, build is performed in an intermediate server and just deploy is executed in the remote server. This is a a little better

---

#3 Local Build (an extra instance is required)

In this approach, the build is performed in the developer machine and its uploaded to some kind of repository. I advice you docker instead of just war or jar compilation.

In order to build and upload the docker image, one of these docker registries are required:

• Docker simple registry
• Amazon Elastic Container Registry (ECR)
• Docker hub.
• Harbor.
• JFrog Container Registry.
• Nexus Container Registry.
• Portus
• Azure Container Registry.

Choose one and install it in a new server. Configure your developer machine and your remote server to point to your new docker registry.

Final steps are:

• Perform a docker build in your developer machine after. This will create a new docker image of your java application (tomcat+war or springboot jar)
• Upload your local image to your new docker registry with something like:

    docker push example.com/test-image

• Connect to your remote cloud linux instance using ssh and just download the docker image

docker pull example.com/test-image

• In the remote server, just start your new downloaded image with docker run...

#4 Use a continuous integration server (an extra instance is required)

Same to the #3 but not in the developer machine. All the steps are performed in another server called: Continuous integration server.

#4.1 Use a continuous integration server (an extra instance is required)

• Install Jenkins or another Continuous integration server in the new instance
• Configure plugins and other required things in jenkins in order to enable webhook url : https://jrichardsz.github.io/devops/configure-webhooks-in-github-bitbucket-gitlab
• Create a job in jenkins to call the script of approach #1 or execute docker commands of approach #2. If you can, Approach #3 would be perfect.
• Configure your SCM (github, bitbucket, gitlab, etc) to point to the webhook url published by Jenkins.

When you are ready to deploy, just push the code to your scm, jenkins will be notified and will execute the previous created job. As you can see, there is no human required to deploy de application in the server(With the exception of developer push)

Note: At this point, you could migrate the scripts of approaches #1 and #2 to :

• Jenkins pipeline script
  • https://gist.github.com/jrichardsz/a62e3790c6db7654808528bd5e5a385f#file-jenkins_scripted_pipeline_java_mvn_basic-js
• Jenkins declarative pipeline
  • https://gist.github.com/jrichardsz/a62e3790c6db7654808528bd5e5a385f#file-jenkins_declarative_pipeline_hello_world-js

These are more advanced and scalable approaches to mapping all the commands and configurations required from the beginning to the deployment.

#5 Advanced (Sysadmin team or extra people and knowledge are required )

More instances and technologies will be required.

• Kubernetes
• Ansible
• High availability / Load balancer
• Backups
• Configurations Management
• And more automations

This will be necessary when more and more web applications, microservices are required in your company/enterprise.

#6 Saas

• All the previous approaches could be simplified using WORLD CLASS platforms like:

• Jelastic

• Heroku

• Openshift, etc