ubuntu20中安装Jenkins

安装

安装jdk11

sh 复制代码

sudo apt install openjdk-11-jdk

查看版本

sh 复制代码

java -version

查看安装位置

sh 复制代码

dpkg -L openjdk-11-jdk

/usr/lib/jvm/java-11-openjdk-amd64

安装net-tools

sh 复制代码

sudo apt install net-tools

安装jenkins

下载安装包

sh 复制代码

curl -L0 https://mirrors.aliyun.com/jenkins/debian/jenkins_2.462_all.deb --output jenkins_2.462_all.deb

安装

复制代码

dpkg -i jenkins_2.462_all.deb

卸载

sh 复制代码

dpkg -r jenkins

修改配置

sh 复制代码

vi /usr/lib/systemd/system/jenkins.service

改为

sh 复制代码

# Unix account that runs the Jenkins daemon
# Be careful when you change this, as you need to update the permissions of
# $JENKINS_HOME, $JENKINS_LOG, and (if you have already run Jenkins)
# $JENKINS_WEBROOT.
User=root
Group=root

重新加载单元

sh 复制代码

systemctl daemon-reload

启动、开机启动

sh 复制代码

sudo systemctl start jenkins
sudo systemctl enable jenkins

验证是否安装成功

sh 复制代码

sudo systemctl status jenkins

在浏览器访问：服务器ip:8080可以看到以下页面

初始化Jenkins

根据页面提示找到密码并填入

sh 复制代码

    sudo cat /var/lib/jenkins/secrets/initialAdminPassword

选择推荐的插件

等待安装

安装失败的可以点击重试继续安装

创建用户，账号密码、邮箱全为admin

点击保存并完成

点击开始使用Jenkins

构建完毕

安装Git

先验证有没有安装

sh 复制代码

git --version

如果没有安装，执行安装命令：

sh 复制代码

sudo apt install git

查看安装git是否成功：

sh 复制代码

git --version

安装位置

sh 复制代码

which git

/usr/bin/git

安装Maven

创建文件夹

sh 复制代码

apt install maven

查看maven版本

sh 复制代码

mvn -v

/usr/share/maven

创建本地仓库文件夹

sh 复制代码

mkdir -p /usr/local/maven/repo

赋予777权限

sh 复制代码

chmod 777 /usr/local/maven/repo

修改maven的setting.xml配置信息

sh 复制代码

vi /etc/maven/settings.xml

配置本地仓库

xml 复制代码

<localRepository>/usr/local/maven/repo</localRepository>

配置阿里云镜像加速

xml 复制代码

<mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>*</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

Jenkins工具配置

在Jenkins主页点击Manage Jenkins

找到Tools点击

配置JDK

点击新增 JDK

指定别名、jdk安装主目录/usr/lib/jvm/java-11-openjdk-amd64

配置Git

输入名字、git路径，Git路径默认为：/usr/bin/git

配置maven

点击新增 Maven，指定名字和Maven的主目录 /usr/share/maven

点击保存，完成配置

配置环境变量

添加全局环境变量

配置JDK

JAVA_HOME

/usr/lib/jvm/java-11-openjdk-amd64

配置Maven

M2_HOME

/usr/share/maven

配置Maven命令path

PATH+EXTRA

$M2_HOME/bin

然后保存

安装插件

SSH server插件

Jenkins打完包需要上传到新的服务器上，此处使用ssh的方式上传，添加ssh插件。

首页点击 Manage Jenkins

找到Plugins

选择available plugins在输入框中输入ssh server，在查询到的列表中勾选，然后点击安装

勾选安装完成之后重启Jenkins

安装Maven插件

角色管理插件

搜索安装

Role-based Authorization Strategy插件

安装完毕之后配置角色管理策略

选择Role-Based Strategy

选择好后保存

添加角色

添加一个全局角色login_role，指定基本登录功能

勾选Read权限

创建项目角色：goods_role，指定Pattern

pattern是一个表达式，可以用来指定该角色的用户可以访问什么样的项目

goods.* 表示只能访问名字以goods开头的项目，注意 . 是必须的

选择赋予权限，此处赋予全部权限，也可以根据实际情况进行授权

再创建order_role角色

授予权限

保存

添加用户

点击添加

指定用户名、密码、全名、邮箱，然后点击新建用户

创建完毕之后会在用户列表看到新建的用户

用同样的方式再创建一个用户

给用户分配角色

给用户分配全局角色

添加用户

填写用户名

用同样的方式再添加一个，然后分配login_role角色

分配项目角色

点击添加用户

添加方式与全局用户一致，添加完毕之后分别分配角色

分配好之后点击保存

新建测试项目

新建项目进行测试

用同样的方式再创建一个，创建完毕如下

此时注销账户，分别用xiang、elvis登录查看项目列表

凭证管理

Manage Jenkins → Credentials

Username with password:用户名和密码比如使用Gitlab拉取代码

SSH Username with private key:使用SSH用户和密钥 SSH免密登录

Secret file:需要保密的文本文件，使用时Jenkins会将文件复制到一个临时目录中，再将文件路径设置到

一个变量中，等构建结束后，所复制的Secret file就会被删除。

Secret text:需要偃存的一个加密的文本串，如钉钉机器人或Github的api token

Certificate:通过上传证书文件的方式

常用的凭证类型有: Username with password(用户密码）和SSH Username with private key (SSH密

钥)

接下来以使用Git工具到Gitlab拉取项目源码为例，演示Jenkins的如何管理Gitlab的凭证。

创建项目

基本配置

Jenkins主页点击新建任务

输入项目名，选择构建一个maven项目，然后点击确定

填写项目描述【可选】

点击源码管理，选择Git，填写仓库地址、选择凭证

指定拉取的分支，然后点击保存

保存完毕之后会在Jenkins主页看到该项目，点击项目名字可以进入到该项目中

构建项目

点击立即构建可以构建项目，Jenkins会自动拉取代码并打包

点击立即构建之后，会在下面的构建历史中添加一条构建信息，点击构建信息进入构建详情

点击控制台输出可以看到构建过程

构建成功如下图所示

下面红框中显示了构建好的jar包在什么位置

Post Steps

在root用户的主目录下创建启动shell脚本

sh 复制代码

vim /root/start.sh

添加以下内容

sh 复制代码

#!/bin/bash

# 拷贝文件
cp /var/lib/jenkins/workspace/test/target/springsecurity-2-0.0.1-SNAPSHOT.jar /usr/project
# 变量保存jar包名
RESOURCE_NAME=springsecurity-2-0.0.1-SNAPSHOT.jar
LOG_FILE=/usr/project/nohup.out

# 获取原进程id
tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep -v kill|awk '{print $2}'`
# tpid=`ps -ef | grep $RESOURCE_NAME | grep -v grep | awk '{print $2}'`
if [ ${tpid} ]; then
echo 'Stop Process...'
kill -15 $tpid
fi
sleep 5
tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep -v kill|awk '{print $2}'`
# tpid=`ps -ef | grep $RESOURCE_NAME | grep -v grep | awk '{print $2}'`
if [ ${tpid} ]; then
echo 'Kill Process!'
kill -9 $tpid
else
echo 'Stop Success!'
fi

tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep -v kill|awk '{print $2}'`
# tpid=`ps -ef | grep $RESOURCE_NAME | grep -v grep | awk '{print $2}'`
if [ ${tpid} ]; then
    echo 'App is running.'
else
    echo 'App is NOT running.'
fi

rm -f tpid
# 创建日志文件、并赋予当前用户写权限
rm -f $LOG_FILE
touch $LOG_FILE
chmod +w $LOG_FILE

# 阻止jenkins杀死项目进程
export BUILD_ID=dontKillMe

# 后台启动项目
nohup java -jar /usr/project/$RESOURCE_NAME > $LOG_FILE 2>&1 &
echo $! > tpid
echo Start Success

授予执行权限

sh 复制代码

chomod +x /root/start.sh

点击项目名

点击配置

找到 Post Steps，添加一个step

选择执行 shell

在输入框中通过指令调用脚本，然后保存

或者直接将脚本填写到这里也行

构建项目

查看日志信息

成功如下所示

pipline

pipline运行在jenkins 2.X版本的核心插件，Pipline就是一套运行于Jenkins上的工作流框架，将原本独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂发布流程，从而实现单个任务很难实现的复杂流程编排和任务可视化。

之前采用的都是Jenkins的自由风格，每个流程都要通过不同的方式设置，并且构建过程中整体流程时不可见的，无法确认每个流程花费的时间，同时不方便问题的定位。

流水线的优势：

**可持续性：**jenkins的重启或者中断后不影响已经执行的Pipline Job
支持暂停：pipline可以选择停止并等待人工输入或批准后再继续执行。
可扩展性：通过groovy的编程更容易的扩展插件。
并行执行：通过groovy脚本可以实现step，stage间的并行执行,提高构建效率。

Jenkins的Pipeline可以让项目的发布整体流程可视化，明确执行的阶段，快速定位问题。让整个项目的生命周期可以通过一个Jenkinsfile文件管理，而且Jenkinsfile文件是可以放在项目中维护。

流水线的分类及对比：

pipline流水线分为脚本式流水线与声明式流水线：

语法差异，声明式的在pipline {}块中定义，脚本式直接以node开始
脚本式的在一台节点执行所有操作，而声明式可以将不同的节点定义到不同的节点执行。
声明式比脚本式的写法更复杂，但功能更强大
目前主要使用声明式较多

脚本式流水线

Groovy脚本基本语法

hello world

groovy 复制代码

pipeline {
    agent any

    stages {
        stage('Hello') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

pipeline {} : 所有脚本命令包含在pipeline{}中
agent any : 指定任务在哪个节点执行（Jenkins支持分布式）
stages ：任务合集，可以指定多个任务
stage：任务
steps：实现任务的具体流程

groovy 复制代码

// 所有脚本命令包含在pipeline{}中
pipeline {  
	// 指定任务在哪个节点执行（Jenkins支持分布式）
    agent any
    
    // 配置全局环境，指定变量名=变量值信息
    environment{
    	host = '192.168.150.135'
    }
 
    // 存放所有任务的合集
    stages {
    	// 单个任务
        stage('pull code') {
        	// 实现任务的具体流程
            steps {
                echo 'git拉取代码'
            }
        }
		// 单个任务
        stage('build project') {
        	// 实现任务的具体流程
            steps {
                echo 'Maven打包项目'
            }
        }
        // 单个任务
        stage('run project') {
        	// 实现任务的具体流程
            steps {
                echo '部署项目'
            }
        }
        // ......
    }
}

拉取Git代码

通过流水线语法生成Checkout代码脚本

在项目首页找到 流水线语法 选项

点击判断生成器，选择从版本控制器拉取代码

填写仓库地址和凭证

选择要拉取的分支，然后点击生成流水线脚本

就可以在下面的文本框中看到生成的脚本了

复制填入到脚本中即可

构建代码

通过脚本执行mvn的构建命令

groovy 复制代码

sh 'mvn clean package -DskipTests'

部署项目

sh 复制代码

#!/bin/bash

# 拷贝文件
cp /var/lib/jenkins/workspace/pipline-test/target/springsecurity-2-0.0.1-SNAPSHOT.jar /usr/project
# 变量保存jar包名
RESOURCE_NAME=springsecurity-2-0.0.1-SNAPSHOT.jar
LOG_FILE=/usr/project/nohup.out

# 获取原进程id
tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep -v kill|awk '{print $2}'`
# tpid=`ps -ef | grep $RESOURCE_NAME | grep -v grep | awk '{print $2}'`
if [ ${tpid} ]; then
echo 'Stop Process...'
kill -15 $tpid
fi
sleep 5
tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep -v kill|awk '{print $2}'`
# tpid=`ps -ef | grep $RESOURCE_NAME | grep -v grep | awk '{print $2}'`
if [ ${tpid} ]; then
echo 'Kill Process!'
kill -9 $tpid
else
echo 'Stop Success!'
fi

tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep -v kill|awk '{print $2}'`
# tpid=`ps -ef | grep $RESOURCE_NAME | grep -v grep | awk '{print $2}'`
if [ ${tpid} ]; then
    echo 'App is running.'
else
    echo 'App is NOT running.'
fi

rm -f tpid
# 创建日志文件、并赋予当前用户写权限
rm -f $LOG_FILE
touch $LOG_FILE
chmod +w $LOG_FILE

# 阻止jenkins杀死项目进程
export BUILD_ID=dontKillMe

# 后台启动项目
nohup java -jar /usr/project/$RESOURCE_NAME > $LOG_FILE 2>&1 &
echo $! > tpid
echo Start Success

groovy 复制代码

stage('Copy file') {
    steps {
        sh 'cp /var/lib/jenkins/workspace/pipline-test/target/springsecurity-2-0.0.1-SNAPSHOT.jar /usr/project'
    }
}

stage('Stop process') {
    steps {
        script {
            def resourceName = "springsecurity-2-0.0.1-SNAPSHOT.jar"
            def logFile = "/usr/project/nohup.out"

            def tpid = sh(script: "ps -ef | grep $resourceName | grep -v grep | awk '{print \\$2}'", returnStdout: true).trim()
            if (tpid) {
                echo 'Stop Process...'
                sh "kill -15 $tpid"
            }

            sh 'sleep 5'

            tpid = sh(script: "ps -ef | grep $resourceName | grep -v grep | awk '{print \\$2}'", returnStdout: true).trim()
            if (tpid) {
                echo 'Kill Process!'
                sh "kill -9 $tpid"
            } else {
                echo 'Stop Success!'
            }

            tpid = sh(script: "ps -ef | grep $resourceName | grep -v grep | awk '{print \\$2}'", returnStdout: true).trim()
            if (tpid) {
                echo 'App is running.'
            } else {
                echo 'App is NOT running.'
            }

            sh 'rm -f tpid'
            sh 'rm -f $logFile'
            sh 'touch $logFile'
            sh 'chmod +w $logFile'

            env.BUILD_ID = 'dontKillMe'
        }
    }
}

stage('Start process') {
    steps {
        sh 'nohup java -jar /usr/project/springsecurity-2-0.0.1-SNAPSHOT.jar > /usr/project/nohup.out 2>&1 &'
        sh 'echo $! > tpid'
        echo 'Start Success'
    }
}

sh 复制代码

// 所有脚本命令包含在pipeline{}中
pipeline {  
    // 指定任务在哪个节点执行（Jenkins支持分布式）
    agent any

    // 配置全局环境，指定变量名=变量值信息
    environment{
        host = '192.168.150.135'
    }

    // 存放所有任务的合集
    stages {
        // 单个任务
        stage('pull code') {
            // 实现任务的具体流程
            steps {
                echo 'git拉取代码'
                checkout scmGit(branches: [[name: '*/dev']], extensions: [], userRemoteConfigs: [[credentialsId: '33b55da2-0cc6-4783-bbbc-1af279e923a2', url: 'https://gitee.com/java-108/security2.git']])
            }
        }
        // 单个任务
        stage('build project') {
            // 实现任务的具体流程
            steps {
                echo 'Maven打包项目'
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Copy file') {
            steps {
                sh 'cp /var/lib/jenkins/workspace/pipline-test/target/springsecurity-2-0.0.1-SNAPSHOT.jar /usr/project'
            }
        }
        stage('Stop process') {
            steps {
                script {
                    def resourceName = "springsecurity-2-0.0.1-SNAPSHOT.jar"
                    def logFile = "/usr/project/nohup.out"
        
                    def tpid = sh(script: 'ps -ef | grep $resourceName | grep -v grep | awk "{print \\$2}"', returnStdout: true).trim()
                    if (tpid) {
                        echo 'Stop Process...'
                        sh 'kill -15 $tpid'
                    }
        
                    sh 'sleep 5'
        
                    tpid = sh(script: 'ps -ef | grep $resourceName | grep -v grep | awk "{print \\$2}"', returnStdout: true).trim()
                    if (tpid) {
                        echo 'Kill Process!'
                        sh "kill -9 $tpid"
                    } else {
                        echo 'Stop Success!'
                    }
        
                    tpid = sh(script: 'ps -ef | grep $resourceName | grep -v grep | awk "{print \\$2}"', returnStdout: true).trim()
                    if (tpid) {
                        echo 'App is running.'
                    } else {
                        echo 'App is NOT running.'
                    }
        
                    sh 'rm -f tpid'
                    sh 'rm -f /usr/project/nohup.out'
                    sh 'touch /usr/project/nohup.out'
                    sh 'chmod +w /usr/project/nohup.out'
                }
            }
        }
        stage('Start process') {
            steps {
                env.BUILD_ID = 'dontKillMe'
                sh 'nohup java -jar /usr/project/springsecurity-2-0.0.1-SNAPSHOT.jar > /usr/project/nohup.out 2>&1 &'
                sh 'echo $! > tpid'
                echo 'Start Success'
            }
        }
    }
}

sh 复制代码

sh '/root/start.sh'

SSH

手动安装插件

以安装Credentials Binding为例

插件商店地址：https://plugins.jenkins.io/

输入框输入要安装的插件名字，点击搜索

搜索到之后，点击卡片

点击How to install获取安装说明

在弹出框中可以看到3种安装方式

上图中是三种下载插件的方式

第一种就是插件商店，但是我们此时的需求，插件商店没有，那么我们就需要使用另外两种下载插件的方式。
方法二是命令工具，jenkins-plugin-cli是一个较新的工具，可能只在Jenkins 2.222及以上版本中提供。该命令不可用的原因还可能是安装方式不同，不在系统的PATH环境变量中。
方法三就是通过连接下载部署的方式。

下面就是使用第三种方式安装

点击releases

复制下载链接

https://updates.jenkins.io/download/plugins/credentials-binding/681.vf91669a_32e45/credentials-binding.hpi

在Jenkins的插件管理中填写链接，点击部署即可