Docker builds jenkins+maven code building and deployment platform

Due to project development, it is often necessary to set up some environments locally for development or testing. As we all know, setting up environments, installing software, and installing middleware are very troublesome things. The installation of some software may need to rely on the installation of other environments. For example, the installation of rabbitmq first requires the Erlang language environment. The installation of a whole set not only wastes time but also causes various problems, which seriously affects the development progress. For developers, life is short, do everything possible to improve development efficiency.

The emergence of Docker is undoubtedly a landmark event for the technology community. Docker is deeply loved by IT professionals due to its rich application image repository, ease of use and portability. Using Docker to deploy or install corresponding applications does not require spending too much time on the installation process, details, and dependencies, and it can be truly used out of the box. This article takes the construction of Jenkins as an example to illustrate the basic operation process of Docker: pulling images, running containers, mounting files, tracking operations, shutting down containers, etc. I hope it will be helpful for technology enthusiasts who are just getting started with Docker.

Docker Basic Concepts

Docker is an open source application container engine that allows developers to package their applications and dependencies into a portable container and then publish it to any popular Linux machine. In fact, the most classic picture of Docker is the "dolphin carrying containers on its back", which fully illustrates the relationship between the Docker engine and the container.
Mastering images, containers, and warehouses basically gives you a good understanding of Docker and allows you to use Docker correctly.

• Image: can be understood as the "source code" or .exe installation file of the application;
• Container: It is an instance of an image after it is run. Its relationship with the image is just like the relationship between an "object" and a "class";
• Warehouse: A warehouse for publishing images. Various images (applications) can be downloaded or pulled from the warehouse. Docker is the engine required for a container to run. All containers run in the engine.

Docker installation process (Centos6.9)

Upgrading the kernel

Centos6.9 needs to upgrade the kernel version before installing Docker. The upgrade process is as follows
1. Introduce key

rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org 
rpm -Uvh http://www.elrepo.org/elrepo-release-6-8.el6.elrepo.noarch.rpm 

2.yum installation

yum --enablerepo=elrepo-kernel -y install kernel-lt 

3. Boot file modification ( grub.conf )

vim /etc/grub.conf 

Set default to 0, default=0

4. Restart

Install docker-io

1. Install EPEL source

yum install http://mirrors.yun-idc.com/epel/6/x86_64/epel-release-6-8.noarch.rpm 

2. Install docker-io

yum -y install docker-io 

3. Start the docker service

service docker start

Jenkins installation based on Docker

Pull application

Before running the container/instance, you need to pull the corresponding image from the docker hub repository. You can check the official website for some introductions on the jenkins image, which contains detailed instructions for installation commands, configuration information, and file directories.
Pull the latest Jenkins from the repository, docker pull jenkins , and pull other versions with the command docker pull jenkins:<version>

Running the container

When running a container/instance, you need to take into account the mapping of local ports to the docker container so that it can be accessed through the local host. Since the container itself does not persist files, Docker does not recommend performing any file-related write operations in the container. It is only used as a "container". If a lot of important data needs to be saved or configured during the operation of the container application, such as MySQL database files, Jenkins plug-ins, configuration files, etc., it is recommended to mount the container files locally, that is, volume mapping.

docker run -p 8080:8080 -p 50000:50000 -v /usr/local/docker_volume/jenkins:/var/jenkins_home -v /usr/local/apps/maven-3.3.9:/var/maven_home -v /usr/local/apps/maven-3.3.9/repo:/usr/local/apps/maven-3.3.9/repo --name my_jenkins -d jenkins

Where -p means port mapping, that is, mapping the port on the local machine to the port on the container;
-v means file mapping, that is, the local machine and the container share the mapping and mount the file
Note : Since Jenkins needs to rely on Maven projects to build Maven projects, the local Maven_home is shared with the container when running the container. Because the container needs to write to the local shared file when it is running, write permission is required. sudo chown -R 1000 sudo chown -R 1000:1000 /usr/local/docker_volume/jenkins sudo chown -R 1000:1000 sudo chown -R 1000:1000

When you run the above command, the container ID will be printed in the window. You can view the running container status and related information through docker ps .

Tracking application logs

Enter docker logs <CONTAINER ID> to track the container print log. When you start Jenkins for the first time, the password will be printed in the log. Copy it and use it to log in to Jenkins.

Close open container

Shutdown: docker stop <CONTAINER ID>
Open: docker start <CONTAINER ID>

tomcat account configuration

In this example, the war compiled by Maven is deployed to the remote tomcat, so you need to set the deployment permissions in tomcat, edit the /con/tomcat-users.xml configuration file, and add the account

<role rolename="tomcat"/>
<role rolename="admin"/>
<role rolename="admin-gui"/>
<role rolename="manager"/>
<role rolename="manager-gui"/>
<role rolename="manager-script"/>
<role rolename="manager-jmx"/>
<role rolename="manager-status"/>
<user username="admin" password="admin" roles="admin,manager,tomcat,manager-gui,manager-script,manager-jmx,manager-status"/>
<user username="root" password="admin" roles="admin,manager,tomcat,manager-gui,manager-script,manager-jmx,manager-status,admin-gui"/>

Configure Jenkins to build and deploy war applications

At this point, you can access the Jenkins platform by visiting http://本機ip:8080 , select the default installation plug-in, and after the installation is successful, select account settings, etc.

Configure JDK, Maven and other parameters

Add JDK installation in "System Settings -> Global Tool Configuration" as shown below

Install the "Deploy to container Plugin" plugin for deploying war programs in "System Settings -> Manage Plugins -> Optional Plugins"

Create a new task to build and deploy

Add SVN source code address and Tomcat deployment address

Tomcat deployment configuration, configure the account to log in tomcat

Deploy Maven project to specified Tomcat through ssh script

Using the above method to implement deployment in Tomcat's built-in deployment consumes a lot of server performance and often causes problems such as memory overflow, resulting in deployment failure. The ssh script deployment method is much more convenient and faster, and does not consume that much memory.

Configure the Publish Over SSH plugin

Install the (Publish Over SSH) plug-in in "System Settings -> Management Plug-ins -> Optional Plug-ins", and then set the login information of the Linux server to be published in "System Management -> System Settings -> Publish over SSH". The configurations and their specific meanings are shown in the figure below. After the configuration is completed, click the [Test Configuration] button to test whether the connection is established. If "Success" is displayed, it means the configuration is successful.

Write a deployment ssh script

Store the following shell script deploy.sh in the /home/admin/data directory of the server and grant execution permission chomd +x deploy.sh , that is, in Remote Directory directory in the ssh login configuration diagram above. This configuration means that after Jenkins logs in to the Linux server where Tomcat is located, you can use ./deploy.sh to perform deployment operations. If demploy.sh is placed in another directory, you can use the absolute path /..dir../..dir../deploy.sh to execute it.

#!/bin/bash
# File: set ff=unix
#defined 
export JAVA_HOME=/usr/local/java
#Tomcat deployment locationTOMCAT_HOME="/home/admin/data/tomcat-jenkins"
# The server user directory after logging in is the same as the Remote Directory setting configured in the figure above LOGIN_HOME="/home/admin/data"
TOMCAT_PORT=10092
PROJECT="$1"
#param validate
if [ $# -lt 1 ]; then
  echo "you must use like this : ./deploy.sh <projectname> [tomcat port] [tomcat home dir]"  
  exit
fi
if [ "$2" != "" ]; then
   TOMCAT_PORT=$2
fi
if [ "$3" != "" ]; then
   TOMCAT_HOME="$3"
fi
#shutdown tomcat
#"$TOMCAT_HOME"/bin/shutdown.sh
#echo "tomcat shutdown"
#check tomcat process

#tomcat_pid=`/usr/sbin/lsof -n -P -t -i :$TOMCAT_PORT`
tomcat_pid=`ps -ef | grep $TOMCAT_HOME | grep -v 'grep\|tail\|more\|bash\|less'| awk '{print $2}'`
echo "current :" $tomcat_pid
while [ -n "$tomcat_pid" ]
do
 sleep 5
 tomcat_pid=`ps -ef | grep $TOMCAT_HOME | grep -v 'grep\|tail\|more\|bash\|less'| awk '{print $2}'`
 echo "scan tomcat pid :" $tomcat_pid
 if [ -n "$tomcat_pid" ]; then
   echo "kill tomcat :" $tomcat_pid
   kill -9 $tomcat_pid
 fi
done
#publish project
echo "scan no tomcat pid,$PROJECT publishing"
rm -rf "$TOMCAT_HOME"/webapps/$PROJECT
cp "$LOGIN_HOME"/war/$PROJECT.war "$TOMCAT_HOME"/webapps/$PROJECT.war
#bak project
#BAK_DIR=/home/web_as/war/bak/$PROJECT/`date +%Y%m%d`
#mkdir -p "$BAK_DIR"
#cp "$TOMCAT_HOME"/webapps/$PROJECT.war "$BAK_DIR"/"$PROJECT"_`date +%H%M%S`.war
#remove tmp
rm -rf "$LOGIN_HOME"/war/$PROJECT.war
#start tomcat
"$TOMCAT_HOME"/bin/startup.sh
echo "tomcat is starting, please try to access $PROJECT conslone url"

Project build configuration

After saving the configuration as shown below, you can build the Maven project. Jenkins will copy the compiled war project to the tomcat path corresponding to 192.168.1.12 server, and then start Tomcat to deploy the project.

This is the end of this article about using docker to build a Jenkins + Maven code build and deployment platform. For more related content about using docker to build Jenkins + Maven, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!