本文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 也可以。

参考资料

Logo
腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

cover

计算机网络微课堂笔记

avatar 腾讯云开发者社区
cover

Rabbitmq在java中的使用

avatar 腾讯云开发者社区

java try catch 之后定位不到具体报错行_JAVA入门（三）上

点击蓝字｜关注我们一、异常与异常处理异常简介代码中：阻止当前方法或作用域继续实现的，称之为异常java中的所有异常类都继承Throwable类，Exception 的父类是 Throwable编码 环境 用户操作输入出现问题由java虚拟机自动抛出和自动捕获需要手动添加抛出和捕获语句文件找不到ThrowableErrorException虚拟机错误 VirtualMachineError...

avatar 腾讯云开发者社区