Jenkins npm config set registry不生效 jenkins配置nexus

环境
　　CentOS Linux release 7.6.1810
　　jdk1.8.0_65
　　apache-tomcat-8.5.45
　　Jenkins-2.235.5
　　apache-maven-3.6.3
　　git-2.9.5
　　gradle-6.6.1
　　SonarQube-7.8
　　sonar-scanner-cli-4.2.0.1873

拓扑：
　　node1:安装GitLab、SonarQube
　　node2:安装Jenkins、Git、maven

一、maven配置

1、安装Maven
安装Maven：使用Maven进行编译，这里要配置setting.xml里的仓库地址，可以是内网的某个nexus,保证开发人员的代码依赖编译正确。

参考：
理解和创建proxy、hosted、group仓库 配置本地项目或maven下载、发布构件到Nexus 

2、配置Maven
配置setting.xml里的仓库地址，可以是内网的某个nexus,保证开发人员的代码依赖编译正确。

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    
    <!--自定义maven本地仓库地址-->
    <localRepository>/data/repo</localRepository>

  <pluginGroups>
  </pluginGroups>

  <proxies>
  </proxies>
    
    <!--nexus服务器登录验证信息 上传构件时要用 和项目pom.xml里的distributionManagement配合使用  两个文件的 id 需要保持一致-->
  <servers>
        <server>
            <id>releases</id>
            <username>admin</username>
            <password>admin123</password>
        </server>
        <server>
            <id>snapshots</id>
            <username>admin</username>
            <password>admin123</password>
        </server>
  </servers>
  
    <!--仓库组的url地址  id和name自定义，mirrorOf的值设置为*，代表maven的所有访问请求都会指向到Nexus仓库组-->  
  <mirrors>
      <mirror> 
            <id>nexus-82.46</id> 
            <name>repo-82.46</name>
            <url>http://192.168.82.46:8081/repository/maven-public/</url> 
            <mirrorOf>*</mirrorOf> 
        </mirror> 
        <mirror>  
      <id>nexus-125.127</id>  
      <name>repo-125.127</name>
      <mirrorOf>central</mirrorOf>
      <url>http://192.168.125.127:8081/repository/maven-public/</url>  
    </mirror>
  </mirrors>

  <profiles>
        <profile> 
            <id>myprofile</id> 
            <repositories> 
                <repository> 
                    <id>central</id> 
                    <url>http://192.168.82.46:8081/repository/maven-public/</url> 
                    <releases> 
                        <enabled>true</enabled> 
                    </releases> 
                    <snapshots> 
                        <enabled>true</enabled> 
                    </snapshots>
                </repository> 
            </repositories>
            <pluginRepositories> 
                <pluginRepository> 
                    <id>central</id> 
                    <url>http://192.168.82.46:8081/repository/maven-public/</url> 
                    <releases> 
                        <enabled>true</enabled> 
                    </releases> 
                    <snapshots> 
                        <enabled>false</enabled> 
                    </snapshots>
                </pluginRepository> 
            </pluginRepositories>
            <activation>
        <activeByDefault>true</activeByDefault>      
        <jdk>1.8</jdk>
      </activation>
      <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
      </properties>
    </profile> 
  </profiles>
</settings>

二、jenkins配置maven编译

(1)这里我们使用一种新的jenkins Item类型：Multibranch Pipeline

(2)这里选择只配置Gitlab 数据源就可以了，默认使用Jenklinsfile作为流水线配置文件

(3)GItlab 上传Jenkinsfile和maven工程

给出pom.xml,jenkinsfile中maven构建参数会用到：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!--模型版本-->
    <modelVersion>4.0.0</modelVersion>
    <!--组织名称，此处使用组织名称+项目名称-->
    <groupId>com.wjy</groupId>
    <!--项目名称-->
    <artifactId>mymaven</artifactId>
    <!-- 当前项目版本号：
        同一个项目开发过程中可以发布多个版本，此处标示1.0版。
        每个工程发布后可以发布多个版本，
        依赖时调取不同的版本，使用不同的版本号 -->
    <version>1.0.0</version>
    <!--名称与访问地址，可省略-->
    <name>hello-world</name>
    <url>http://maven.apache.org</url>
 
    <!--定义编码格式-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
 
    <!--依赖库-->
    <dependencies>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

(4)每次修改Jenkinsfile文件都要刷一下：Scan Multibranch Pipeline Now  会使新修改的Jenkinsfile生效

(5)通过Blue Ocean查看

jenkins任务工作空间目录：

[root@node106 HelloWorldTest_master]# tree
.
├── mymaven
│   ├── Jenkinsfile
│   ├── pom.xml
│   ├── README.md
│   ├── src
│   │   ├── main
│   │   │   └── java
│   │   │       └── com
│   │   │           └── wjy
│   │   │               └── App.java
│   │   └── test
│   │       └── java
│   │           └── com
│   │               └── wjy
│   │                   └── AppTest.java
│   └── target
│       ├── classes
│       │   └── com
│       │       └── wjy
│       │           └── App.class
│       ├── generated-sources
│       │   └── annotations
│       ├── generated-test-sources
│       │   └── test-annotations
│       ├── maven-archiver
│       │   └── pom.properties
│       ├── maven-status
│       │   └── maven-compiler-plugin
│       │       ├── compile
│       │       │   └── default-compile
│       │       │       ├── createdFiles.lst
│       │       │       └── inputFiles.lst
│       │       └── testCompile
│       │           └── default-testCompile
│       │               ├── createdFiles.lst
│       │               └── inputFiles.lst
│       ├── mymaven-1.0.0.jar
│       ├── surefire-reports
│       │   ├── com.wjy.AppTest.txt
│       │   └── TEST-com.wjy.AppTest.xml
│       └── test-classes
│           └── com
│               └── wjy
│                   └── AppTest.class
└── mymaven@tmp

30 directories, 15 files

 

这里重点研究下Jenkinsfile 这里使用脚本式语法：

node{
    def workspace=pwd()
    jar_name='mymaven'
    
    //拉取代码 或者使用 checkout scm
    stage 'checkout'
        println "checkout"
        dir('mymaven'){
            git branch: 'master', credentialsId: 'gitlab-wangjy', url: 'http://134.32.82.46:19527/wjy/maven-basic.git'
        }
        
    //编译 执行mvn命令
    stage 'build'
        println "build"
        sh """ 
        cd $workspace/mymaven
        /usr/local/apache-maven-3.6.3/bin/mvn clean install -U -P coverage
        """
        
    //备份 根据war包在备份目录制作一个tar包用来备份
    stage 'backup'
        println "backup"
        sh"""
        cd $workspace/'$jar_name'/target
        tar cfz /data/.jenkins/workspace/backup/'$jar_name'`date +%y%m%d-%s`.tar.gz '$jar_name'-1.0.0.jar
        """
    
    //删除目标主机
    
    //上传编译后打包
    
    //重启tomcat
}

注意：

$workspace 可以直接引用，$jar_name需要加单引号'';
maven参数-P coverage:-P maven将触发pom.xml文件中coverage环境的profile配置，在实际中可以设置为不同的研发版本设置，比如dev-开发版本，test-测试版本，uat-准生产版本，prod-生产版本

　　关于自动构建过程中自动打包配置文件，可以参考：jenkins+maven动态打包配置文件

引入一个完整版的Jenkinsfile 包含拉取代码，编译，打包，删除旧部署文件，上传新包，重启Tomcat，借助sshpass使用比较老的部署方式，目前都是使用Ansible插件、或者Docker打镜像。

node{
    //工作空间
    def workspace=pwd()
    war_name='mymaven'
    
    //部署主机登录信息
    host='127.0.0.1'
    user='wjy'
    passwd='wjy'
    tomcat_home=''
    
    
    //拉取代码 或者使用 checkout scm
    stage 'checkout'
        println "checkout"
        dir('mymaven'){
            git branch: 'master', credentialsId: 'gitlab-wangjy', url: 'http://134.32.82.46:19527/wjy/maven-basic.git'
        }
        
    //编译 执行mvn命令
    stage 'build'
        println "build"
        sh """ 
        cd $workspace/mymaven
        /usr/local/apache-maven-3.6.3/bin/mvn clean install -U -P coverage
        """
        
    //备份 根据war包在备份目录制作一个tar包用来备份
    stage 'backup'
        println "backup"
        sh"""
        cd $workspace/'$war_name'/target
        tar cfz /data/.jenkins/workspace/backup/'$war_name'`date +%y%m%d-%s`.tar.gz '$war_name'-1.0.0.war
        """
    
    //删除目标主机 
    //StrictHostKeyChecking=no #主机key检查，当你第一次连接某台机器时，会出现交互式页面，避免出现这种情况 设置no
    stage 'delete_old'
        println "delete_old"
        sh """
        sshpass -p '$passwd' ssh -o StrictHostKeyChecking=no '$user'@'$host' "rm -rf  '$tomcat_home'/deploy/'$war_name'* "
        """
    
    //上传编译后打包
    stage 'upload'
        println "upload"
        sh """
            cd $workspace/'$war_name'/target
            sshpass -p '$passwd' scp -o StrictHostKeyChecking=no '$war_name'.jar '$user'@'$host':'$tomcat_home'/deploy/'$war_name'.war
        """
        
    //重启tomcat
    stage 'restart_tomcat'
        println "restart_tomcat"
        sh "sshpass  -p '$passwd' ssh -o StrictHostKeyChecking=no '$user'@'$host' 'bash /home/admin/if_tomcat.sh'"
    
    echo 'done_______________'
}

 三、Jenkins制品管理

1、jenkins借助maven管理制品

maven deploy plugin主要是为了用来将artifact部署到远程仓库中。

<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-deploy-plugin</artifactId>
        <version>2.8.2</version>
    </plugin>
</plugins>

使用Deploy插件发布需要以下几个步骤：
(1)配置发布地址。在Maven项目的POM文件中加入：

<distributionManagement>
        <repository>
            <id>releases</id>
            <name>public</name>
            <url>http://192.168.82.46:9999/nexus/content/repositories/releases/</url>
        </repository>
        <snapshotRepository>
            <id>releases</id>
            <name>Snapshots</name>
            <url>http://192.168.82.46:9999/nexus/content/repositories/snapshots/</url>
        </snapshotRepository>
    </distributionManagement>

Deploy插件会根据Maven项目中定义的version值决定是使用nexus-snapshot仓库还是nexus-release仓库。当version值是以-SNAPSHOT后缀结尾时，则发布到nexus-snapshot仓库。

(2)配置访问Nexus的用户名和密码。在Nexus中，我们配置了只有授权的用户名和密码才能发布制品。这时需要在Maven的settings.xml中加入配置：

<servers>
    <server>
    <id>releases</id>
    <username>admin</username>
    <password>Aa123456</password>
    </server>
    <server>
    <id>snapshots</id>
    <username>admin</username>
    <password>Aa123456</password>
    </server>
  </servers>

(3)执行命令mvn clean deploy 制品上传制品到nexus

2、使用archiveArtifacts本地存档
archiveArtifacts步骤能对制品进行归档，然后你就可以从Jenkins页面上下载制品了。
(1)新建Multibranch Pipeline 项目，配置GitLab，默认使用Jenkinsfile构建。
(2)这里使用声明式pipeline

pipeline{
    agent any
    //安装maven3.6.3
    tools{
        maven 'mvn-3.6.3'
    }
    stages{
        stage('Build'){
            steps{
                //打包
                sh "mvn clean package"
            }
        }
    }
    //事后生成归档
    post{
        always{
            archiveArtifacts artifacts: 'target/**/*.jar',fingerprint: true
        }
    }
}

archiveArtifacts的参数：
• artifacts（必填）：字符串类型，需要归档的文件路径，使用的是Ant风格路径表达式。
• fingerprint（可选）：布尔类型，是否对归档的文件进行签名。
• excludes（可选）：字符串类型，需要排除的文件路径，使用的也是Ant风格路径表达式。
• caseSensitive（可选）：布尔类型，对路径大小写是否敏感。
• onlyIfSuccessful（可选）：布尔类型，只在构建成功时进行归档。
archiveArtifacts步骤并不只用于归档JAR包，事实上，它能归档所有类型的制品

(3)BlueOcean构建

(4)页面提供归档文件下载连接

实际就是连接到target下的生成的jar文件.

[root@node106 target]# pwd
/data/.jenkins/workspace/HelloWorldTest_master/mymaven/target
[root@node106 target]# ll
total 4
drwxr-x--- 3 root root   17 Sep 14 16:34 classes
drwxr-x--- 3 root root   25 Sep 14 16:34 generated-sources
drwxr-x--- 3 root root   30 Sep 14 16:34 generated-test-sources
drwxr-x--- 2 root root   28 Sep 14 16:35 maven-archiver
drwxr-x--- 3 root root   35 Sep 14 16:34 maven-status
-rw-r----- 1 root root 2523 Sep 14 16:35 mymaven-1.0.0.jar
drwxr-x--- 2 root root   65 Sep 14 16:35 surefire-reports
drwxr-x--- 3 root root   17 Sep 14 16:34 test-classes

备注：这种方式是将部署包生成在本地保存，生产中用的不多。

3、使用jenkins插件Nexus Platform

(1)jenkins 安装Nexus Platform插件

(2)在我们自己的nexus私服里创建一个hosted类型cicd-release制品仓库

(3)在Jenkinsfile中加入nexusPublisher步骤。

pipeline{
    agent any
    //默认含有checkout SCM,所以这里没有显式的拉取代码,如果是拉取其他版本的代码这里可以添加默认含有checkout
    stages{
        stage('Build'){
            steps{
                //打包
                sh "mvn clean test package"
                nexusPublisher(
                    nexusInstanceId:'nexus3-82.46',
                    nexusRepositoryId: 'cicd-release',
                    packages: [
                        [
                            $class: 'MavenPackage',
                            mavenAssetList: [
                                [
                                    classifier: '',
                                    extention: '',
                                    filePath: './target/mymaven-1.0.0.jar'
                                ]
                            ],
                            mavenCoordinate:[
                                artifactId: 'mymaven',
                                groupId: 'com.wjy',
                                packaging: 'jar',
                                version: '1.0.0'
                            ]
                        ]
                    ],
                )
            }
        }
    }
}

nexusPublisher的参数介绍：
• nexusInstanceId：在Jenkins中配置Nexus 3.x时的Server ID。
• nexusRepositoryId：发布到Nexus服务器的哪个仓库。
• mavenCoordinate：Maven包的坐标，packaging值与Maven中的packaging值一致，可以是jar、war、pom、hpi等。
• mavenAssetList：要发布的文件，如果是pom.xml，则extension必须填“xml”。
此插件的缺点：
• 每个Maven项目都可能不同，必须为每个Maven项目写nexusPublisher方法。
• 对于多模块的Maven项目，nexusPublisher的参数写起来十分啰唆，而且容易写错，实际工作中用的也不多。

(4)去仓库里查看上传的制品

4、使用Nexus管理Docker镜像
(1)在Nexus里创建Docker私有仓库
进入Nexus的仓库列表页：Administration→Repository→Repositories，单击“docker（hosted）”

 

(2)jenkins所在机器要安装docker

使用docker制作镜像，然后将镜像推送到Nexus，然后后面k8s会从Nexus拉取镜像去部署。
注意：由于是私有的非安全（HTTP）的仓库，所以需要配置Docker的daemon.json：否则会报错Error response from daemon: Get https://192.168.82.46:18083/v2/: http: server gave HTTP response to HTTPS client

[root@node2 local]# vim /etc/docker/daemon.json
{
    "insecure-registries":["192.168.82.46:18083"],
    "registry-mirrors": ["http://hub-mirror.c.163.com"]
}

参考：Docker部署安装 

(3)编写pipiline

pipeline{
    agent any
    environment{
        registry="http://192.168.82.46:18083"
        registryCredential='nexus3-82.46'
    }
    stages{
        stage('Build'){
            steps{
                //制作镜像
                withDockerRegistry([credentialsId: "${registryCredential}",url:"${registry}"]){
                    sh "docker build . -t 192.168.82.46:18083/hello:v1"
                    sh "docker tag 192.168.82.46:18083/hello:v1 192.168.82.46:18083/hello:v1"
                    sh "docker push 192.168.82.46:18083/hello:v1"
                }
            }
        }
    }
}

withDockerRegistry步骤做的事情：

先执行命令：docker login -u admin -p ******** http://192.168.82.46:18083;其间所生成的config.json文件会存储在工作空间中。然后再执行闭包内的命令。

(3.1)在本地上传私有镜像的时候遇到的报错：http: server gave HTTP response to HTTPS client
原因是：Docker自从1.3.X之后docker registry交互默认使用的是HTTPS，但是搭建私有镜像默认使用的是HTTP服务，所以与私有镜像交时出现以上错误。

解决办法是：vim /etc/docker/daemon.json 增加 "insecure-registries":["192.168.82.46:18083"]

(3.2)报错：Get https://192.168.82.46/v2/: dial tcp 192.168.82.46:443: connect: connection refused
原因：没有指定镜像要上传的地址，站点。默认的是docker.io
解决方法：
docker tag <imagesname> <ip:port/image>
docker push ip:port/image

参考：docker上传的一些问题

(4)去nexus查看镜像制品

5、Nexus raw制品管理
raw仓库可以被理解为一个文件系统，我们可以在该仓库中创建目录。

(1)创建raw仓库

(2)编写pipiline,上传制品，获取制品
使用HTTP客户端就可以将制品上传到raw仓库中,我们使用Linux curl命令,如果目录不存在，nexus将会自动创建

pipeline{
    agent any
    environment{
        nexusRawUsernamePassword=credentials('nexus3-82.46')
    }
    stages{
        stage('Build'){
            steps{
                sh "curl --user '${nexusRawUsernamePassword}' --upload-file ./target/mymaven-1.0.0.jar http://192.168.82.46:8081/repository/cicd-raw-release/2/mymaven-1.0.0.jar"
            }
        }
    }
}

 

(4)在Jenkins pipeline中获取原始制品时，我们同样使用curl命令。

sh "curl --user '${nexusRawUsernamePassword}' -o mymaven-1.0.0.jar http://192.168.82.46:8081/repository/cicd-raw-release/2/mymaven-1.0.0.jar"

6、从其他pipeline中拷贝制品
(1)jenkins安装Copy Artifact插件
Copy Artifact Plugin插件是将某个job的构建物copy到当前job的工作空间，以此来将不同的job进行关联。
注意构建物也就是构建后会进行存档的文件，使用此插件只能copy存档的文件，而不是直接copy工作空间.

(2)HelloWorldTest编写pipiline归档文件，并赋权给archivetest允许拷贝

pipeline{
    agent any
    //用来指定哪些任务可以拷贝
    options {
        copyArtifactPermission('archivetest*');
    }
    stages{
        stage('Build'){
            steps{
                //打包
                sh "mvn clean package"
            }
        }
    }
    //事后生成归档
    post{
        always{
            archiveArtifacts artifacts: 'target/**/*.jar',fingerprint: true
        }
    }
}

(3)archivetest拷贝HelloWorldTest编译成功的文件

pipeline{
    agent any
    stages{
        stage('Copy Archive'){
            steps{
                script {
                    echo env.JOB_NAME
                    copyArtifacts filter: 'target/*.jar', fingerprintArtifacts: true, projectName: 'HelloWorldTest/master', selector: lastSuccessful()
                }
            }
        }
    }
}

在各脚本编写遇到很多问题，其实是可以参考 Pipeline Syntax,不会写pipeline 就去里面根据后面问号里提示填写 然后生成脚本复制进去就行了

copyArtifacts步骤的参数详解：
• projectname（必填）：字符串类型，Jenkins job或pipeline名称。
• selector：BuildSelector类型，从另一个pipeline中拷贝制品的选择器，默认拷贝最后一个制品。
• parameters：字符串类型，使用逗号分隔的键值对字符串（name1=value1，name2=value2），用于过滤从哪些构建中拷贝制品。
• filter：字符串类型，Ant风格路径表达式，用于过滤需要拷贝的文件。
• excludes：字符串类型，Ant风格路径表达式，用于排除不需要拷贝的文件。
• target：字符串类型，拷贝制品的目标路径，默认为当前pipeline的工作目录。
• optional：布尔类型，如果为true，则拷贝失败，但不影响本次构建结果。
• fingerprintArtifacts：布尔类型，是否对制品进行签名，默认值为true。
• resultVariableSuffix：上例中，无法得知我们到底拿的是core项目的哪次构建的制品。CopyArtifact 插件的设计是将其构建次数放到一个环境变量中。这个环境变量名就是在COPYARTIFACT BUILD NUMBER 后拼上resultVariableSuffix，比如resultVariableSuf fix值为corejob，那么就在pipeline中通过变量COPYARTIFACT BUILD NUMBER corejob拿到源pipeline的构建次数了。

几种常用的获取选择器：
• lastSuccessful：最后一次构建成功的制品。方法签名为lastSuccessful（boolean stable）。stable为true表示只取构建成功的制品，为false表示只要构建结果比UNSTABLE好就行。
• specific：指定某一次构建的制品。方法签名为specific（String buildNumber）。buildNum ber表示指定取第n次构建的制品。
• lastCompleted：最后一次完成构建的制品，不论构建的最终状态如何。方法签名为lastCompleted（）。
• latestSavedBuild：最后一次被标记为keep forever的构建的制品。方法签名为latestSavedBu ild（）。

参考：Copy Artifact plugin

(4)构建

拷贝结果：注意是将jar所在目录一起拷贝过来

[root@node2 target]# pwd
/data/.jenkins/workspace/archivetest_master/target
[root@node2 target]# ll
total 4
-rw-r----- 1 root root 2521 Sep 15 15:20 mymaven-1.0.0.jar

7、版本号管理

语义化版本格式为：主版本号.次版本号.修订号。版本号递增规则如下：
• 主版本号：当作了不兼容的API修改时。
• 次版本号：当作了向下兼容的功能性新增时。
• 修订号：当作了向下兼容的问题修正时。
先行版本号及版本编译元数据可以加到“主版本号.次版本号.修订号”的后面，作为延伸。以下是常用的修饰词。
• alpha：内部版本。
• beta：测试版本。
• rc：即将作为正式版本发布。
• lts：长期维护。

方便生成版本号的Version Number插件

pipeline{
    agent any
    stages{
        stage('create version'){
            steps{
                script{
                    def version=VersionNumber versionPrefix:"${JOB_NAME}-",versionNumberString: 'v1.1.1.${BUILDS_ALL_TIME}'
                    echo "${version}"
                }
            }
        }
    }
}

VersionNumber步骤支持以下参数。

• versionNumberString：字符串类型，版本号格式，用于生成版本号。只能使用单引号，以防格式中的占位符被转义。版本号格式支持多种占位符，稍后介绍。
• versionPrefix：字符串类型，版本号的前缀。
• projectStartDate：字符串类型，项目开始时间，格式为yyyy-MM-dd，用于计算项目开始后的月数和年数。
• worstResultForIncrement：字符串类型，如果本次构建状态比上一次构建状态更糟糕，则BUILDS_TODAY、BUILDS_THIS_WEEK、BUILDS_THIS_MONTH、BUILDS_THIS_YEAR占位符的值不会增加。worstResultForIncrement可以设置的值有SUCCESS、UNSTABLE、FAILURE、ABORTED、NOT_BUILT（默认）。此参数较少使用。versionNumberString参数使用占位符生成版本号。部分占位符本身支持参数化。接下来分别介绍它们。
• BUILD DATE FORMATTED：格式化的构建日期，支持参数化，如${BUILD DATEFORMATTED，"yyyy-MM-dd"}。
• BUILD DAY：构建日期，支持X和XX参数。比如是12月2日，${BUILD DAY}将返回2，${BUILD DAY，X}将返回2，${BUILD DAY，XX}将返回03。
• BUILD WEEK：今年构建的星期数，支持X和XX参数。
• BUILD MONTH：今年构建的月数，支持X和XX参数。
• BUILD YEAR：今年构建的年份。

比如构建的时间为2018-12-02，那么BUILD_DAY的值为2，BUILD_WEEK的值为49，BUILD_MONTH的值为12，BUILD_YEAR的值为2018。

接下来是一组和构建数相关的占位符：BUILDS TODAY、BUILDS THIS WEEK、BUILDS THISMONTH、BUILDS THIS YEAR，它们分别表示当天、本星期、本月、本年完成的构建数。
BUILDS ALL TIME表示自从项目开始后完成的总构建数。MONTHS SINCE PROJECT START和YEARS SINCE PROJECT START分别表示自项目开始日期起已过去的日历月数和年数

参考：翟志军 Jenkins2.X实践指南

四、清理工作目录

workspace：工作空间，可以随便删除，删除后再次构建时间可能会比较长，因为要重新获取一些资源；
job：存放的是项目的配置、构建结果、日志等。不建议手动删除，手动删除的后果往往需要重新部署
(1)对于自由风格project的配置中，General部分有个Discard old builds
在这里，我选择给项目配置丢弃旧的构建这种模式，保持构建的天数和保持最大构建数根据项目的需要设置，保留了7天内构建的最多5次记录。配置完后，需要重新构建一次，才起作用，这时候我们的job空间会大大缩小。

对于Multibranch Pipeline项目 设置Orphaned Item Strategy：

(2)使用工作空间选项清理

(3)安装Workspace Cleanup plugin插件

对于自由风格project，在构建后操作Post-build Actions添加delete workspace when build is done

如果使用pipeline：使用如下

编写Jenkinsfile：

pipeline{
    agent any
    stages{
        stage('Copy Archive'){
            steps{
                script {
                    echo env.JOB_NAME
                    copyArtifacts filter: 'target/**/*.jar', fingerprintArtifacts: true, projectName: 'HelloWorldTest/master', selector: lastSuccessful()
                }
            }
        }
    }
    post{
        always{
            cleanWs cleanWhenAborted: false, cleanWhenFailure: false, cleanWhenNotBuilt: false, cleanWhenUnstable: false
        }
    }
}

构建结果：

查看工作空间：

之前未清理：

[root@node2 workspace]# ll
drwxr-x--- 5 root root 128 Sep 15 18:11 archivetest_master
drwxr-x--- 2 root root   6 Sep 15 18:11 archivetest_master@tmp
-rw-r----- 1 root root  82 Sep 15 09:50 workspaces.txt

添加清理步骤后：

[root@node2 workspace]# ll
drwxr-x--- 2 root root   6 Sep 15 18:11 archivetest_master@tmp
-rw-r----- 1 root root  82 Sep 15 09:50 workspaces.txt

 

参考：

jenkins pipeline构建

jenkins制品管理 

学习技术不是用来写HelloWorld和Demo的，而是要用来解决线上系统的真实问题的.