docker+jenkins+github实现golang项目自动部署

本文jenkins部署golang项目流程

1. jenkins服务拉取github上的项目
2. 构建golang项目并生成docker镜像[jenkins调用的是宿主机上的docker环境，如何调用的，后面会说明]
3. 启动golang项目的docker镜像

docker的安装这里就不说了

docker安装jenkins

Makefile

docker run -u root  -d  -p 8888:8080 -v /docker/jenkins_home:/var/jenkins_home --privileged=true  --name jenkins    jenkins/jenkins:latest

run:
	docker run -u root -d 	-p 8088:8080 	-p 50000:50000 \
	--privileged=true -e TZ="Asia/Shanghai" \
	-v /Users/chen/data/docker/jenkins:/var/jenkins_home \
	-v /var/run/docker.sock:/var/run/docker.sock \
	-v /usr/local/bin/docker:/usr/bin/docker \
	--name jenkins \
	jenkins/jenkins:lts

说明：
-v /Users/chen/data/docker/jenkins:/var/jenkins_home 挂载jenkins的home目录，jenkins安装的插件,拉取的项目代码都在这个目录里
-v /var/run/docker.sock:/var/run/docker.sock与-v /usr/local/bin/docker:/usr/bin/docker 挂载这两个文件就能在docker容器内访问宿主机上的docker。官方文档里有说明

容器内安装必备软件

#等待3分钟后，我们进入Jenkins容器内    
 docker exec -it jenkins /bin/bash
#更新                          
apt-get update
#安装GCC跟VIM :                
apt install vim            
apt install gcc

我们在Jenkins容器里做一个跟gitlab的域名映射。(IP是我们上面查询的噢~)     172.21.0.3  git.guaosi.com
安装GOLANG

# 下载
wget https://studygolang.com/dl/golang/go1.15.6.linux-amd64.tar.gz
 
# 解压
tar -C /usr/local -zxvf go1.15.6.linux-amd64.tar.gz
 

# 添加进环境变量
vim /etc/profile

# 在最后一行添加
export GOROOT=/usr/local/go
export PATH=$PATH:$GOROOT/bin

# wq保存退出后source一下
source /etc/profile

#修改~/.bashrc
vim ~/.bashrc
export GOROOT=/usr/local/go  
export GOPATH=$PATH:$GOROOT/bin 
# 激活配置
source ~/.bashrc

安装docker

sudo apt install docker.io
sudo systemctl enable docker
docker --version


vim /etc/docker/daemon.json
{ "insecure-registries":["192.168.100.30:8080"] }

service docker restart

给JENKINS换源

cd /var/jenkins_home/updates

sed -i 's/http:\/\/updates.jenkins-ci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json && sed -i 's/http:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json

重启容器
docker restart jenkins

由于种种原因最后还是选择ubuntu直接安装jenkins

安装Java SDK

由于默认的更新源比较慢，修改为阿里云的更新源

vim /etc/apt/sources.list

清空文件内容，添加如下内容：

 

deb http://mirrors.aliyun.com/ubuntu/ xenial main restricted
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted
deb http://mirrors.aliyun.com/ubuntu/ xenial universe
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates universe
deb http://mirrors.aliyun.com/ubuntu/ xenial multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu xenial-security main restricted
deb http://mirrors.aliyun.com/ubuntu xenial-security universe
deb http://mirrors.aliyun.com/ubuntu xenial-security multiverse

 

正式安装java jdk

apt-get update
sudo apt-get install -y openjdk-8-jdk
apt-get clean all

二、安装Jenkins

注意：这里我是单独用了一台服务器，来安装Jenkins

包含在默认Ubuntu软件包中的Jenkins版本往往落后于项目本身的最新版本。 为了利用最新的修复和功能，我们将使用项目维护的软件包来安装Jenkins。

首先，我们将存储库密钥添加到系统。

wget -q -O - https://pkg.jenkins.io/debian/jenkins-ci.org.key | sudo apt-key add -

添加密钥后，系统将返回OK 。 接下来，我们将Debian包存储库地址附加到服务器的sources.list ：

echo deb http://pkg.jenkins.io/debian-stable binary/ | sudo tee /etc/apt/sources.list.d/jenkins.list

当这两个都到位时，我们将运行update ，以便apt-get将使用新的存储库：

sudo apt-get update

最后，我们将安装Jenkins及其依赖项，包括Java：

sudo apt-get install -y jenkins

现在Jenkins及其依赖项已经到位，我们将启动Jenkins服务器。

如果你的`/etc/init.d/jenkins`文件无法启动Jenkins，编辑`/etc/default/jenkins`， 修改 ----HTTP_PORT=8080----`为----HTTP_PORT=8081----` 在这里，“8081”也可被换为其他可用端口。

三、开始Jenkins

使用systemctl我们将启动Jenkins：

sudo systemctl start jenkins

由于systemctl不显示输出，我们将使用其status命令来验证它是否成功启动：

sudo systemctl status jenkins

#dial unix /var/run/docker.sock: connect: permission denied.
sudo groupadd docker #添加docker用户组
sudo gpasswd -a $USER docker #将登陆用户加入到docker用户组中
docker ps #测试当前用户是否可以正常使用docker命令
---------------------------------
可以使用sudo root权限执行，但我们还是想要用jenkins用户来做这件事。只要把jenkins添加到docker的group里就可以了。
sudo usermod -a -G docker jenkins
这时候，重新jenkins构建依旧是不行的。需要刷新session。所以，需要重启jenkins。

Jenkinsfile中使用docker push到私服的时候报错，报错信息如下：

unauthorized: unauthorized to access repository: ocp/eureka-server, action: push: unauthorized to access repository: ocp/eureka-server, action: push
这是因为jenkins在推送镜像的时候使用的是jenkins的伪用户，那么既然要推送就要登录，那么首先在当前用户生成config.json

当前用户使用docker login生成config.json
当前用户下使用如下命令进行登录

docker login harbor.aiuyo.com:643
输入用户名和你们之后在当前用户根目录的.docker目录下生成一个config.json文件，内容如下：

[wangxianfeng@hs ~]$ cat .docker/config.json 
{
        "auths": {
                "harbor.aiuyo.com:643": {
                        "auth": "d2FuZ3hpYW5mZW5nOlhpYW5mZW5nOTk="
                }
        }
}
把.docker复制到/var/lib/jenkins目录下
使用root登录后
将/用户名/.docker/目录拷贝到/var/lib/jenkins下
修改文件夹权限 chown -R jenkins.jenkins .docker
# cp -r .docker/ /var/lib/jenkins/
# cd /var/lib/jenkins/
# chown -R jenkins.jenkins .docker

1. 安装后访问 http://127.0.0.1:8088/login

   

    

2. 获取登录密码

docker exec -it jenkins cat /var/jenkins_home/secrets/initialAdminPassword

1. 选择“选择插件来安装”[ 插件安装很慢，参考 Jenkins安装插件提速]

   

    

2. 选择插件

Localization: Chinese (Simplified)
Docker
Github
Go
SSH

1. 添加凭据[Jenkins>凭据>系统>全局凭据]
   用于拉取github上的代码
   需要在jenkins容器里生成ssh

# 进入容器
docker exec -it jenkins bash
# 生成ssh，一路回车就行了
ssh-keygen -t rsa
# 获取密钥，下图Private Key的值
cat ~/.ssh/id_rsa
# 获取公钥，加入到github的 SSH keys 里
cat ~/.ssh/id_rsa.pub

1. 全局工具配置[Jenkins>全局工具配置]

   

    

2. 创建任务
   (1). 创建任务

   

   
   (2). 设置参数与源码管理。VERSION会在构建docker容器时用到，相当项目版本号；Git> Credentialst选择第5步创建的凭据

   

   
   (3). 构建环境与构建

   

   
   Dockerfile

FROM alpine:latest
RUN mkdir -p /app
WORKDIR /app

ADD main /app/main

EXPOSE 9999

CMD ["./main"]

cd $WORKSPACE

export GOPROXY=https://goproxy.io

go mod tidy
# 打印依赖，部署成功后查看版本依赖是否如预期
cat ./go.mod

cd ./app/test/http
# linux环境编译
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o main
# 构建docker镜像，项目中需要在当前目录下有dockerfile，否则构建失败
docker build -t qicmsg/test/demo:$VERSION .
rm -rf main
docker rm http_test -f
docker run --name http_test -p 9999:9999 -d qicmsg/test/demo:$VERSION

1. 开始构建项目

   

   
   到这里整体流程就走完了。docker container ls 就能看到刚启动的容器了。

注：在实际中，通常是jenkins是一台服务器，运行golang项目的是一台独立的服务器(集群可以用k8s来部署)。在jenkins构建项目后，构建docker镜像docker build 并提交到docker仓库docker push。然后在7.(3)步的构建后操作通过ssh来执行远端命令部署项目

----------------------------------------------------------------------------------------------------------------------------------

4、安装 Go Plugin 插件并配置

Jenkins 配置完毕后，在正式执行 Go 工程编译前，我们需要安装一个 Go Plugin 插件，该插件主要完成以下几个功能：

• 提供各预编译版本 GO 安装包，方便 Jenkins 所在机器执行安装。
• 配置 GOROOT 环境变量，并指向安装的 Go 工具。
• 添加 $GOROOT/bin 到系统 PATH 中，以方便构建时使用 GO 工具时可以直接使用。

说明一下，我们知道 GO 项目执行编译，需要指定好 GOROOT 以及配置 GOPATH 到环境变量中，这里插件直接帮我们配置好了，当然如果觉得默认配置路径不合适，我们也可以在执行构建时临时临时指定其他目录，下边会讲到。

安装该插件，点击 “系统管理” -> “管理插件” -> “可选插件” -> 选择 “Go Plugin” -> 点击最下边 “直接安装” 即可完成安装。

安装完毕后，我们进入到 “系统管理” -> “Global Tool Configuration” -> “Go” -> “新增 Go”，默认情况下，插件自动安装 “Install from golang.org”，我们直接选择 Go 版本以及配置别名即可，如下图。

 

But，由于国内网络的问题，想要直接从 golang.org 上下载安装包可不是那么随意的，那该怎么办呢？我们可以选择非自动安装，直接在机器上安装 Go，然后在这里指定 Go 安装目录即可。例如，这里我提前在机器 /var/jenkins_home/go 目录安装好了系统对应版本的 Go-1.11 版本的安装包，直接配置即可。Go 环境详细安装过程，可参考 Go 官网 文档.

安装完毕后，我们就可以使用 Go Plugin 插件啦！有两种方式使用该插件。

• Freestyle 类型 Job

  针对该类型的 Job，可以在 “构建环境” 项下选择 “Set up Go programming language tools”，然后在上边已配置的 “Go version” 下选择某一版本即可。

  

• 我们来测试一下这种方式，选择 go 1.11 版本，然后输出一下 GOROOT、PATH 等环境变量。

  echo "GOROOT: ${GOROOT}"
  echo "PATH: ${PATH}"
  echo "GOPATH: ${GOPATH}"
  go version
  

  看下日志输出，的确使用了 go 1.11 版本，并且自动设置了 GOROOT 和添加了 $GOROOT/bin 到系统 PATH 中。

  ......
  03:49:59 [go_build_test] $ /bin/sh -xe /tmp/jenkins6920182511078977565.sh
  03:49:59 + echo GOROOT: /var/jenkins_home/go
  03:49:59 GOROOT: /var/jenkins_home/go
  03:49:59 + echo PATH: /var/jenkins_home/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
  03:49:59 PATH: /var/jenkins_home/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
  03:49:59 + echo GOPATH: 
  03:49:59 GOPATH: 
  03:49:59 + go version
  03:49:59 go version go1.11 linux/amd64
  

• ipeline 类型 Job

  该方式使用 Jenkins Pipeline 来运行该插件，可以使用 tool 工具来指定类型为 go，并指定 name 为上边配置的 Go 别名，配置一下 Go 运行环境，即可使用该版本 Go 环境啦！例如一个简单的 Pipeline Script 示例如下：

  node {
      stage('show go version'){
         def root = tool name: 'go 1.11', type: 'go'
         withEnv(["GOROOT=${root}", "PATH+GO=${root}/bin"]) {
              sh 'go version'
          }
      }
  }
  

5、配置 Jenkins Job 构建 Go 工程

插件调试完毕，接下来我们就可以配置构建 Go 工程，这里我以一个自己测试的简单的 Beego 框架搭建的项目 apiproject 为例，项目源码在 Github 这里 可以下载到。新建一个 Freestyle 的名称为 go_build_test 的 Job，并配置源码管理和构建脚本如下图：

说明一下：

1. 源码管理处，我添加了 Check out to a sub-directory 并配置为 $WORKSPACE/src/apiproject，为什么要这样操作呢？我们知道，Go 运行需要指定 GOPATH 也即项目运行路径，默认情况下为 $GOROOT/src，跟我配置的不一致，这里我要指定当前 Job 的WORKSPACE 为项目构建路径，这样做的好处是：1、每个 Job 拥有自己工作空间下独立的构建路径，跟其他 Job 隔离开，避免不同项目对同一插件依赖的版本不一致导致的问题。2、每个 Job 在自己工作空间下，可以通过 Web 页面直接查看文件，方便排查问题。当然坏处就是：一旦我们清理了该 Job 的工作空间，那么下次执行时会重新拉取各个插件依赖，会耗时久一些。
2. 同时还添加了 “Check out to a specific local branch”，并配置为 master，这里是因为 Check out to a sub-directory 操作会将当前分支变为一个游离分支，而下边 go get -u -v 操作更新当前项目的时候是有要求的，首先远端仓库必须是 https 协议地址，其次本地分支必须跟远端已存在的相同分支关联。所以，这里我们可以将分支切换回 master 分支（因为上边配置的默认为 master 分支）
3. 构建脚本中，我执行了 export GOPATH=$WORKSPACE 和 export PATH=$GOPATH:$PATH 目的是为了将当前 Job 工作空间当做项目构建目录。
4. 构建脚本中，我执行了 git branch --set-upstream-to=origin/master master 这里是为了使本地分支与远端分支做关联，否则 go get -u -v 操作不通过。

配置完毕后，执行立即构建，看下妥妥没问题。

可以看到工作空间里面，apiproject 工程成功构建。

6、使用 Golang 镜像执行编译

除了上边使用 Go Plugin 插件完成 Go 项目的编译之外，我们还可以是使用 Golang 官方镜像很容易来完成构建，我们来看下该如何实现，首先项目根目录新建一个 dockerfile 文件如下。

FROM golang:1.11

WORKDIR /go/src/apiproject

COPY . .

RUN go get -d -v && go install -v

CMD ["sh", "-c", "/go/bin/apiproject"]

单说下，我们以 golang:1.11 作为基础镜像，因为该环境中已经安装好了 Go 环境，而且默认配置了 /go/src 为其构建路径，那么只需要将项目源码复制到该目录下（要注意项目名，不然源码中 import 包名会出错的哈），当然也可以使用挂载方式。最后执行拉取依赖和编译，启动编译后的文件即可。

接下来，制作镜像并启动一下看下。

$ docker build -t go-project/apiproject:v1.0.1 .
Sending build context to Docker daemon  2.655MB
Step 1/5 : FROM golang:1.11
 ---> fb7a47d8605b
Step 2/5 : WORKDIR /go/src/apiproject
Removing intermediate container 55586ebf0681
 ---> 5439da2e4f7d
Step 3/5 : COPY . .
 ---> 463d0a861f9d
Step 4/5 : RUN go get -d -v && go install -v
 ---> Running in c777400529e9
github.com/astaxie/beego (download)
github.com/go-sql-driver/mysql (download)
github.com/pkg/errors (download)
apiproject/bean
github.com/astaxie/beego/orm
github.com/pkg/errors
github.com/astaxie/beego/config
github.com/go-sql-driver/mysql
github.com/astaxie/beego/utils
github.com/astaxie/beego/vendor/gopkg.in/yaml.v2
github.com/astaxie/beego/session
github.com/astaxie/beego/logs
github.com/astaxie/beego/grace
github.com/astaxie/beego/toolbox
github.com/astaxie/beego/vendor/golang.org/x/crypto/acme
github.com/astaxie/beego/context
github.com/astaxie/beego/vendor/golang.org/x/crypto/acme/autocert
apiproject/models
github.com/astaxie/beego/context/param
github.com/astaxie/beego
apiproject/controllers
apiproject/routers
apiproject
Removing intermediate container c777400529e9
 ---> df774ffdeaff
Step 5/5 : CMD ["sh", "-c", "/go/bin/apiproject"]
 ---> Running in fff870787128
Removing intermediate container fff870787128
 ---> d7705fd98b5d
Successfully built d7705fd98b5d
Successfully tagged go-project/apiproject:v1.0.1

像制作完毕，启动一下试试看。

$ docker run -p 8089:8089 --name apiproject d7705fd98b5d
2018/09/29 10:00:35.117 [I] [parser.go:96]  generate router from comments
2018/09/29 10:00:35.119 [I] [router.go:269]  /go/src/apiproject/controllers no changed
2018/09/29 10:00:35.123 [I] [asm_amd64.s:1333]  http server Running on http://:8089
2018/09/29 10:00:49.373 [D] [server.go:2741]  |     172.17.0.1| 302 |     120.64µs|   match| GET      /swagger
2018/09/29 10:00:49.379 [D] [server.go:2741]  |     172.17.0.1| 200 |   1.105248ms|   match| GET      /swagger/
2018/09/29 10:00:49.460 [D] [server.go:2741]  |     172.17.0.1| 200 |   1.987006ms|   match| GET      /swagger/swagger-ui.css
2018/09/29 10:00:49.472 [D] [server.go:2741]  |     172.17.0.1| 200 |  11.403196ms|   match| GET      /swagger/swagger-ui-standalone-preset.js
2018/09/29 10:00:49.474 [D] [server.go:2741]  |     172.17.0.1| 200 |  16.388701ms|   match| GET      /swagger/swagger-ui-bundle.js
2018/09/29 10:00:50.044 [D] [server.go:2741]  |     172.17.0.1| 200 |   2.538031ms|   match| GET      /swagger/swagger.json
2018/09/29 10:00:50.223 [D] [server.go:2741]  |     172.17.0.1| 200 |   1.517141ms|   match| GET      /swagger/favicon-32x32.png
2018/09/29 10:00:50.276 [D] [server.go:2741]  |     172.17.0.1| 200 |   2.631284ms|   match| GET      /swagger/favicon-16x16.png

志显示启动成功，我们使用浏览器访问 http://127.0.0.1:8089/swagger/，妥妥没有问题。

7、使用 Docker 多阶段构建镜像

Docker 17.05.0-ce 版本以后支持多阶段构建。使用多阶段构建，我们可以在 Dockerfile 中使用多个 FROM 语句，每条 FROM 指令可以使用不同的基础镜像，这样可以选择性地将服务组件从一个阶段 COPY 到另一个阶段，在最终镜像中只保留需要的内容。想想之前遇到镜像需要依赖另一个镜像运行后的服务组件，通常我们需要创建多个 Dockerfile，然后通过挂载的方式将依赖的另一镜像的服务组件挂出，复制到最终镜像中，非常麻烦，例如我们典型的应用场景，一个编译镜像，一个运行镜像，运行镜像依赖编译镜像编译后的产物。

同时，上边我们使用 golang:1.11 镜像先编译后运行，最终的镜像大小达到了 813M，增加了磁盘使用量和下载时间，使得我们整个部署时间大大延长。接下来，演示一下使用 Docker 多阶段构建镜像方式，方便的制作出一个能够运行只包含 Go 编译后产物的镜像，而且镜像体积大大减小。

首先我们新建一个名称为 Multistage.dockerfile 的 dokerfile 文件如下。

# 编译镜像
FROM golang:1.11 AS builderImage
WORKDIR /go/src/apiproject
COPY . .
RUN go get -v && go install && mv /go/bin/apiproject /root

# 产物运行镜像
FROM scratch
WORKDIR /root
COPY --from=builderImage /root .
EXPOSE 8089
CMD ["/root/apiproject"]

单说下，该 dockerfile 包含了两部分：编译镜像和产物运行镜像，编译镜像跟上边演示的 dockerfile 一样负责生成编译后产物，产物运行镜像通过 COPY --from 语句即可将编译后的产物复制到该镜像内部，最后运行该产物即可。这里提一下，产物运行镜像我采用了 scratch 作为基础镜像，scratch 是一个空镜像，只能用于构建其他镜像，因为它体积很小，能够最大限度的减小我们的产物运行镜像大小（当然也可以使用 busybox、alpine 等小体积镜像）。

接下来，我们来执行 build 构建，看下执行过程吧！

$ docker build -t go-project/apiproject:v1.0.2 -f Multistage.dockerfile .
Sending build context to Docker daemon  2.656MB
Step 1/9 : FROM golang:1.11 AS builderImage
 ---> fb7a47d8605b
Step 2/9 : WORKDIR /go/src/apiproject
 ---> Using cache
 ---> 5439da2e4f7d
Step 3/9 : COPY . .
 ---> Using cache
 ---> f1c8116af400
Step 4/9 : RUN go get -v && go install && mv /go/bin/apiproject /root
 ---> Running in 7a5e5e04b61f
github.com/astaxie/beego (download)
github.com/go-sql-driver/mysql (download)
github.com/pkg/errors (download)
apiproject/bean
github.com/astaxie/beego/orm
github.com/pkg/errors
github.com/astaxie/beego/config
github.com/go-sql-driver/mysql
github.com/astaxie/beego/utils
github.com/astaxie/beego/vendor/gopkg.in/yaml.v2
github.com/astaxie/beego/session
github.com/astaxie/beego/logs
github.com/astaxie/beego/grace
github.com/astaxie/beego/toolbox
github.com/astaxie/beego/vendor/golang.org/x/crypto/acme
github.com/astaxie/beego/context
github.com/astaxie/beego/vendor/golang.org/x/crypto/acme/autocert
github.com/astaxie/beego/context/param
apiproject/models
github.com/astaxie/beego
apiproject/controllers
apiproject/routers
apiproject
Removing intermediate container 7a5e5e04b61f
 ---> 7c014b441b75
Step 5/9 : FROM scratch
 --->
Step 6/9 : WORKDIR /root
Removing intermediate container e0fc1e337360
 ---> 07e1b208bdcc
Step 7/9 : COPY --from=builderImage /root .
 ---> be659716bed8
Step 8/9 : EXPOSE 8089
 ---> Running in 76059331c67a
Removing intermediate container 76059331c67a
 ---> 9756d11d714a
Step 9/9 : CMD ["/root/apiproject"]
 ---> Running in 44bfc2f11c31
Removing intermediate container 44bfc2f11c31
 ---> f7ef0d72e876
Successfully built f7ef0d72e876
Successfully tagged go-project/apiproject:v1.0.2

build 成功，来对比下两种不同方式 build 出来的镜像，我们会发现最后构建出的镜像远远小于使用 golang 镜像构建方式生成的镜像。

$ docker images
REPOSITORY                                    TAG                 IMAGE ID            CREATED             SIZE
go-project/apiproject                         v1.0.2              f7ef0d72e876        2 hours ago         22.9MB
<none>                                        <none>              7c014b441b75        2 hours ago         813MB
go-project/apiproject                         v1.0.1              d7705fd98b5d        24 hours ago        813MB

明一下，这里的 <none> 镜像是一个无用镜像，也即是 dockerfile 中的编译镜像 builderImage，当编译完成后，它的使命就完成了。其大小刚好跟上边使用 golang 镜像构建方式生成的镜像一样大，因为他们是使用的同样的基础镜像和构建过程。

8、常见问题处理

• 问题一：执行 git clone 时缺少软件依赖

  Jenkins 执行 shell 命令行 clone git 仓库时，报错如下：

  Peer reports incompatible or unsupported 
  git clone https://github.com/huwanyang/beeg...
  Cloning into 'beego-apiproject'...
  fatal: unable to access 'https://github.com/huwanyang/beeg...': Peer reports incompatible or unsupported protocol version.
  

  现这个问题的原因是由于 Jenkins 运行所在机器缺少一些软件依赖或者软件依赖版本太低，解决办法就是执行 yum update -y nss curl libcurl (针对 Centos 系统) 执行更新。

• 问题二：安装 Go Plugin 时依赖插件导败失败

  Jenkins 插件中心执行安装 Go Plugin 插件时显示失败，提示 Structs Plugin 插件版本低。这是因为 Go Plugin 依赖 Structs 插件版本需要 >= 1.7，当安装 Go Plugin 时会自动安装到最新版，但是需要重启 Jenkins 即可。

• 问题三：执行 go get -u -x 报错

  执行 go get -u -x 会每次都会更新当前项目和依赖插件，但是它要求本地分支必须跟远程分支做关联以及 https 协议地址，否则报错信息如下：

  09:09:34 cd /var/jenkins_home/workspace/go_build_test/src/apiproject; git pull --ff-only
  09:09:34 There is no tracking information for the current branch.
  09:09:34 Please specify which branch you want to merge with.
  09:09:34 See git-pull(1) for details.
  09:09:34 
  09:09:34     git pull <remote> <branch>
  09:09:34 
  09:09:34 If you wish to set tracking information for this branch you can do so with:
  09:09:34 
  09:09:34     git branch --set-upstream-to=origin/<branch> master
  

  07:38:08 package probe: cannot download, http://xxx.xxx.xxx.com/huwanyang/apiproject.git uses insecure protocol
  

  现如上错误，是因为 go get 默认规则所致，那么解决方案为执行 go get -u -x 时指定更新的插件，这样就忽略掉本身所在项目，或者只执行 go get 即不执行更新。如果更新时非要本地分支跟远程分支做关联，那么执行前加上 git branch --set-upstream-to=origin/<branch> master 也可以。

参考资料

• Github golang
• Jenkins Go+Plugin
• golang doc