二十一 DevOps进阶
DevOps体系核心概念
敏捷开发：
提高开发效率，及时跟进用户需求，缩短开发周期。
敏捷开发包括编写代码和构建代码两个阶段，可以使用git或者svn来管理代码，用maven对代码进行构建
持续集成：
持续集成强调开发人员提交了新代码之后，立刻自动的进行构建、（单元）测试。根据测试结果，我们可以确定新代码和原有代码能否正确地集成在一起。持续集成过程中很重视自动化测试验证结果，对可能出现的一些问题进行预警，以保障最终合并的代码没有问题。
持续交付：
持续交付在持续集成的基础上，将集成后的代码部署到更贴近真实运行环境的「类生产环境」（production-like environments）中。交付给质量团队或者用户，以供评审。如果评审通过，代码就进入生产阶段。如果所有的代码完成之后一起交付，会导致很多问题爆发出来，解决起来很麻烦，所以持续集成，也就是没更新一次代码，都向下交付一次，这样可以及时发现问题，及时解决，防止问题大量堆积。
持续部署：
持续部署是指当交付的代码通过评审之后，自动部署到生产环境中。持续部署是持续交付的最高阶段。Puppet，SaltStack和Ansible是这个阶段使用的流行工具。容器化工具在部署阶段也发挥着重要作用。 Docker和k8s是流行的工具，有助于在开发，测试和生产环境中实现一致性。 除此之外，k8s还可以实现自动扩容缩容等功能。
(一) Jenkinsfile的使用
上面讲过流水线支持两种语法，即声明式和脚本式，这两种语法都支持构建持续交付流水线。并且都可以用来在Web UI或Jenkinsfile中定义流水线，不过通常将Jenkinsfile放置于代码仓库中（当然也可以放在单独的代码仓库中进行管理）。
创建一个Jenkinsfile并将其放置于代码仓库中，有以下好处：
Ø 方便对流水线上的代码进行复查/迭代；
Ø 对管道进行审计跟踪；
Ø 流水线真正的源代码能够被项目的多个成员查看和编辑。
1.环境变量
静态变量
Jenkins有许多内置变量可以直接在Jenkinsfile中使用，可以通过JENKINS_URL/pipeline-syntax/globals#env获取完整列表。目前比较常用的环境变量如下：
Ø BUILD_ID：当前构建的ID，与Jenkins版本1.597+中的BUILD_NUMBER完全相同；
Ø BUILD_NUMBER：当前构建的ID，和BUILD_ID一致；
Ø BUILD_TAG：用来标识构建的版本号，格式为：jenkins-{BUILD_NUMBER}，可以对产物进行命名，比如生产的jar包名字、镜像的TAG等；
Ø BUILD_URL：本次构建的完整URL，比如：http://buildserver/jenkins/job/MyJobName/17/；
Ø JOB_NAME：本次构建的项目名称；
Ø NODE_NAME：当前构建节点的名称；
Ø JENKINS_URL：Jenkins完整的URL，需要在System Configuration设置；
Ø WORKSPACE：执行构建的工作目录。
上述变量会保存在一个Map中，可以使用env.BUILD_ID或env.JENKINS_URL引用某个内置变量：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent any
stages {
stage('Example') {
steps {
echo "Running ${env.BUILD_ID} on ${env.JENKINS_URL}"
}
}
}
}
对应的脚本式流水线如下：
Jenkinsfile (Scripted Pipeline)
node {
echo "Running ${env.BUILD_ID} on ${env.JENKINS_URL}"
}
除了上述默认的环境变量，也可以手动配置一些环境变量：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent any
environment {
CC = 'clang'
}
stages {
stage('Example') {
environment {
DEBUG_FLAGS = '-g'
}
steps {
sh 'printenv'
}
}
}
}
上述配置了两个环境变量，一个CC值为clang，另一个是DEBUG_FLAGS值为-g。但是两者定义的位置不一样，CC位于顶层，适用于整个流水线，而DEBUG_FLAGS位于stage中，只适用于当前stage。
1.动态变量
动态变量是根据某个指令的结果进行动态赋值，变量的值根据指令的执行结果而不同。如下所示：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent any
environment {
// 使用 returnStdout
CC = """${sh(
returnStdout: true,
script: 'echo "clang"'
)}"""
// 使用 returnStatus
EXIT_STATUS = """${sh(
returnStatus: true,
script: 'exit 1'
)}"""
}
stages {
stage('Example') {
environment {
DEBUG_FLAGS = '-g'
}
steps {
sh 'printenv'
}
}
}
}
Ø returnStdout：将命令的执行结果赋值给变量，比如上述的命令返回的是clang，此时CC的值为“clang ”。注意后面多了一个空格，可以用.trim()将其删除；
Ø returnStatus：将命令的执行状态赋值给变量，比如上述命令的执行状态为1，此时EXIT_STATUS的值为1。
2.凭证管理
Jenkins的声明式流水线语法有一个credentials()函数，它支持secret text（加密文本）、username 和password（用户名和密码）以及secret file（加密文件）等。接下来看一下一些常用的凭证处理方法。
1.加密文本
本实例演示将两个Secret文本凭证分配给单独的环境变量来访问Amazon Web服务，需要提前创建这两个文件的credentials（实践的章节会有演示），Jenkinsfile文件的内容如下：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent {
// Define agent details here
}
environment {
AWS_ACCESS_KEY_ID = credentials('jenkins-aws-secret-key-id')
AWS_SECRET_ACCESS_KEY = credentials('jenkins-aws-secret-access-key')
}
stages {
stage('Example stage 1') {
steps {
//
}
}
stage('Example stage 2') {
steps {
//
}
}
}
}
说明：
上述示例定义了两个全局变量AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY，这两个变量引用的是credentials的两个加密文本，并且这两个变量均可以在stages直接引用（通过AWS_ACCESS_KEY_ID）。
注意如果在steps中使用echo $AWS_ACCESS_KEY_ID，此时返回的是****，加密内容不会被显示出来。
2.用户名密码
本示例用来演示credentials账号密码的使用，比如使用一个公用账户访问Bitbucket、GitLab、Harbor等。假设已经配置完成了用户名密码形式的credentials，凭证ID为jenkins-bitbucket-common-creds。
可以用以下方式设置凭证环境变量（BITBUCKET_COMMON_CREDS名称可以自定义）：
environment {
BITBUCKET_COMMON_CREDS = credentials('jenkins-bitbucket-common-creds')
}
上述的配置会自动生成3个环境变量：
Ø BITBUCKET_COMMON_CREDS：包含一个以冒号分隔的用户名和密码，格式为username:password；
Ø BITBUCKET_COMMON_CREDS_USR：仅包含用户名的附加变量；
Ø BITBUCKET_COMMON_CREDS_PSW：仅包含密码的附加变量。
此时，调用用户名密码的Jenkinsfile如下：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent {
// Define agent details here
}
stages {
stage('Example stage 1') {
environment {
BITBUCKET_COMMON_CREDS = credentials('jenkins-bitbucket-common-creds')
}
steps {
//
}
}
stage('Example stage 2') {
steps {
//
}
}
}
}
注 意：此时环境变量的凭证仅作用于stage 1，也可以配置在顶层对全局生效
3.加密文件
需要加密保存的文件，也可以使用credential，比如链接到Kubernetes集群的kubeconfig文件等。
假如已经配置好了一个kubeconfig文件，此时可以在Pipeline中引用该文件：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent {
// Define agent details here
}
environment {
MY_KUBECONFIG = credentials('my-kubeconfig')
}
stages {
stage('Example stage 1') {
steps {
sh("kubectl --kubeconfig $MY_KUBECONFIG get pods")
}
}
}
}
更多其它类型的凭证可以参考：https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#handling-credentials。
3.参数处理
声明式流水线支持很多开箱即用的参数，可以让流水线接收不同的参数以达到不同的构建效果，在Directives小节讲解的参数均可用在流水线中。
在Jenkinsfile中指定的parameters会在Jenkins Web UI自动生成对应的参数列表，此时可以在Jenkins页面点击Build With Parameters来指定参数的值，这些参数可以通过params变量被成员访问。
假设在Jenkinsfile中配置了名为Greeting的字符串参数，可以通过${params.Greeting}访问该参数，比如：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent any
parameters {
string(name: 'Greeting', defaultValue: 'Hel1o', description: 'How should I greet the world?')
}
stages {
stage('Example') {
steps {
echo "${params.Greeting} World!"
}
}
}
}
对应的脚本式流水线如下：
Jenkinsfile (Scripted Pipeline)
properties([parameters([string(defaultValue: 'Hello', description: 'How should I greet the world?', name: 'Greeting')])])
node {
echo "${params.Greeting} World!"
}
4.使用多个代理
流水线允许在Jenkins环境中使用多个代理，这有助于更高级的用例，例如跨多个平台执行构建、测试等。
比如，在Linux和Windows系统的不同agent上进行测试：
Jenkinsfile (Declarative Pipeline)
pipeline {
agent none
stages {
stage('Build') {
agent any
steps {
checkout scm
sh 'make'
stash includes: '**/target/*.jar', name: 'app'
}
}
stage('Test on Linux') {
agent {
label 'linux'
}
steps {
unstash 'app'
sh 'make check'
}
post {
always {
junit '**/target/*.xml'
}
}
}
stage('Test on Windows') {
agent {
label 'windows'
}
steps {
unstash 'app'
bat 'make check'
}
post {
always {
junit '**/target/*.xml'
}
}
}
}
}
(二) DevOps平台建设
首先先来学习下在Kubernetes中进行CICD的过程，一般的步骤如下：
- 在GitLab中创建对应的项目；
- 配置Jenkins集成Kubernetes集群，后期Jenkins的Slave将为在Kubernetes中动态创建的Slave；
- Jenkins创建对应的任务（Job），集成该项目的Git地址和Kubernetes集群；
- 开发者将代码提交到GitLab；
- 如有配置钩子，推送（Push）代码会自动触发Jenkins构建，如没有配置钩子，需要手动构建；
- Jenkins控制Kubernetes（使用的是Kubernetes插件）创建Jenkins Slave（Pod形式）；
- Jenkins Slave根据流水线（Pipeline）定义的步骤执行构建；
- 通过Dockerfile生成镜像；
- 将镜像提送（Push）到私有Harbor（或者其它的镜像仓库）；
- Jenkins再次控制Kubernetes进行最新的镜像部署；
- 流水线结束删除Jenkins Slave。
1.Jenkins安装
Jenkins安装
首先需要一个Linux服务器，配置不低于2C4G和40G硬盘。首先安装Docker：
# yum install -y yum-utils device-mapper-persistent-data lvm2
# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# sed -i -e '/mirrors.cloud.aliyuncs.com/d' -e '/mirrors.aliyuncs.com/d' /etc/yum.repos.d/CentOS-Base.repo
# yum install docker-ce-19.03.* docker-ce-cli-19.03.* -y
# systemctl daemon-reload && systemctl enable --now docker
创建Jenkins的数据目录，防止容器重启后数据丢失：
# mkdir /data/jenkins_data -p
# chmod -R 777** **/data/jenkins_data
启动Jenkins，并配置管理员账号密码为admin/admin123：
# docker pull bitnami/jenkins:2.319.1-debian-10-r11
# docker run -d --name=jenkins --restart=always -e JENKINS_PASSWORD=admin123 -e JENKINS_USERNAME=admin -e JENKINS_HTTP_PORT_NUMBER=8080 -p 8080:8080 -p 50000:50000 -v /data/jenkins_data:/bitnami/jenkins bitnami/jenkins:2.319.1-debian-10-r11
e987d004e62b8412e33911eea2c37ffc81b559fb6c3075060b2ea78bac3cae45
其中8080端口为Jenkins Web界面的端口，50000是jnlp使用的端口，后期Jenkins Slave需要使用50000端口和Jenkins主节点通信。
查看Jenkins日志：
# docker logs -f Jenkins
... # 查看到这条日志说明Jenkins已完成启动
INFO: Jenkins is fully up and running
之后通过Jenkins宿主机的IP+8080即可访问Jenkins
插件安装
登录后点击Manage Jenkins---> Manage Plugins安装需要使用的插件：
在安装之前首先配置国内的插件源，点击Advanced，将插件源更改为国内插件源（https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json）：
点击Check now后在Available可以看到所有的可用插件：
本课程需要的插件如下所示：
Git
Git Parameter
Git Pipeline for Blue Ocean
GitLab
Credentials
Credentials Binding
Blue Ocean
Blue Ocean Pipeline Editor
Blue Ocean Core JS
Pipeline SCM API for Blue Ocean
Dashboard for Blue Ocean
Build With Parameters
Dynamic Extended Choice Parameter Plug-In
Dynamic Parameter Plug-in ？？
Extended Choice Parameter
List Git Branches Parameter
Pipeline
Pipeline: Declarative
Kubernetes
Kubernetes CLI
Kubernetes Credentials
Image Tag Parameter
Active Choices
勾选后，点击Download now and install after restart：
之后可以在Installed看到已经安装的插件：
至此Jenkins和Jenkins插件的安装就完成了，接下来安装Harbor和GitLab。
2.GitLab安装
GitLab在企业内经常用于代码的版本控制，也是DevOps平台中尤为重要的一个工具，接下来在另一台服务器（4C4G40G以上）上安装GitLab（如果同样有可用的GitLab，也可无需安装）。
首先在GitLab国内源下载GitLab的安装包：https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/。
将下载后的rpm包，上传到服务器，之后通过yum直接安装即可：
# yum install gitlab-ce-14.2.3-ce.0.el7.x86_64.rpm -y
安装完成后，需要更改几处配置：
# vim /etc/gitlab/gitlab.rb
将external_url更改为自己的发布地址，可以是服务器的IP，也可以是一个可被解析的域名：
大部分公司内可能已经有了Prometheus监控平台，所以GitLab自带的Prometheus可以无需安装，后期可以安装GitLab Exporter即可进行监控。关闭Prometheus插件（可选）：
更改完成后需要重新加载配置文件：
# gitlab-ctl reconfigure
加载配置完成以后，可以看到如下信息：
Notes:
Default admin account has been configured with following details:
Username: root
Password: You didn't opt-in to print initial root password to STDOUT.
Password stored to /etc/gitlab/initial_root_password. This file will be cleaned up in first reconfigure run after 24 hours.
NOTE: Because these credentials might be present in your log files in plain text, it is highly recommended to reset the password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.
gitlab Reconfigured!
之后可以通过浏览器访问GitLab，账号root，默认密码在/etc/gitlab/initial_root_password：
登录后，可以创建一个测试项目，进行一些简单的测试。首先创建一个组：
组名为kubernetes，类型为Private，之后点击Create group即可：
之后在该组下创建一个Project：
选择创建一个空的项目：
输入项目名称，然后点击Create project即可：
之后可以将Jenkins服务器的key导入到GitLab，首先生成密钥（如有可以无需生成）：
# ssh-keygen -t rsa -C "YOUR_EMAIL@ADDRESS.COM"
将公钥的内容放在GitLab中即可：
# cat ~/.ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC44ni3FivVXHkGcJ3E1bk3mugx6e8aDqKR1MPQP0idb0XGRQp3kNJ244pypRoj/w1OIBWtb5Pj3fT8rxGaW/bzyAHpeAWsmXYtZdZ3q/kbzPfp1yHcjG0RrWs9Fb1LPohHdsoV+FOqaAlO73kXOJUem/BSbeGmQVCP5toQbO0NaHPBqGE3V5dPJxscEqzsFmlrH/WhM+bF3gWlc7AiO4SySFM2tJ7gUMsMXhB1F5kaT1vZPcn1BF4SNvDrHv0bt+uMcYXAAKTmUUdZcpG2tBA8izVblnZPHgIS0Xyu+kGfkxMZFzoGhJXgUkTlwNC3qruBNNcKf7BXB/wd5f+vS+Xl root@k8s-master01
在GitLab找到Profile：
之后在SSH Keys添加公钥：
添加后就可以在Jenkins服务器拉取代码：
# yum install git -y
# git clone git@YOUR_GITLAB_ADDRESS:kubernetes/test-project.git
Cloning into 'test-project'...
The authenticity of host 'YOUR_GITLAB_ADDRESS (YOUR_GITLAB_ADDRESS)' can't be established.
ECDSA key fingerprint is SHA256:+S7xLeFMNznoIzwOQDMHHj2spo08wxP4+HI6MgZPlP0.
ECDSA key fingerprint is MD5:e0:92:c3:aa:4e:dc:26:8e:bc:92:f0:94:b3:fb:26:61.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'YOUR_GITLAB_ADDRESS' (ECDSA) to the list of known hosts.
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (3/3), done.
创建几个文件，然后提交测试：
# ls
test-project
# cd test-project/
# ls
README.md
# echo "# Frist Commit For DevOps" > first.md
# ls
first.md README.md
# git add .
# git commit -am "first commit"
[main a327add] first commit
1 file changed, 1 insertion(+)
create mode 100644 first.md
# git push origin main
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 302 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To git@YOUR_GITLAB_ADDRESS:kubernetes/test-project.git
b64564e..a327add main -> main
提交之后在GitLab即可看到该文件：
3.安装Harbor
首先在GitHub下载最新的Harbor离线包，并上传至Harbor服务器，官方下载地址：https://github.com/goharbor/harbor/releases/
由于Harbor是采用docker-compose一键部署的，所以Harbor服务器也需要安装Docker：
# yum install -y yum-utils device-mapper-persistent-data lvm2
# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# sed -i -e '/mirrors.cloud.aliyuncs.com/d' -e '/mirrors.aliyuncs.com/d' /etc/yum.repos.d/CentOS-Base.repo
# yum install docker-ce-19.03.* docker-ce-cli-19.03.* -y
# systemctl daemon-reload && systemctl enable --now docker
安装完成后，将下载的Harbor离线包解压并载入Harbor镜像：
# tar xf harbor-offline-installer-v2.3.2.tgz
# cd harbor
# docker load -i harbor.v2.3.2.tar.gz
之后安装Compose：
# curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose
# docker-compose -v
docker-compose version 1.29.2, build 5becea4c
Harbor默认提供了一个配置文件模板，需要更改如下字段：
# cp harbor.yml.tmpl harbor.yml
# vim harbor.yml
Ø hostname：Harbor的访问地址，可以是域名或者IP，生产推荐使用域名，并且带有证书；
Ø https：域名证书的配置，生产环境需要配置权威证书供Harbor使用，否则需要添加insecure-registry配置，由于是学习环境，所以本示例未配置证书；
Ø 账号密码按需修改即可，默认为admin:Harbor12345。
之后修改Harbor的数据目录：
创建Harbor数据目录并进行预配置：
# mkdir /data/harbor /var/log/harbor -p
# ./prepare
prepare base dir is set to /root/harbor
WARNING:root:WARNING: HTTP protocol is insecure. Harbor will deprecate http protocol in the future. Please make sure to upgrade to https
...
Generated configuration file: /compose_location/docker-compose.yml
Clean up the input dir
执行安装：
# ./install.sh
Creating network "harbor_harbor" with the default driver
Creating harbor-log ... done
Creating redis ... done
Creating harbor-db ... done
Creating harbor-portal ... done
Creating registryctl ... done
Creating registry ... done
Creating harbor-core ... done
Creating nginx ... done
Creating harbor-jobservice ... done
✔ ----Harbor has been installed and started successfully.----
成功启动后，即可通过配置的地址或域名访问：
如果配置不是https协议，所有的Kubernetes节点的Docker（如果是containerd作为Runtime，可以参考下文配置insecure-registry）都需要添加insecure-registries配置：
# cp -p /usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service.bak
# vi /usr/lib/systemd/system/docker.service
# diff /usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service.bak
14c14
< ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --insecure-registry=192.168.8.202:80---
> ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
# systemctl daemon-reload
# systemctl restart docker
登录测试：
# docker login YOUR_HARBOR_ADDRESS：80
Username: admin
Password:
...
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
接下来在Harbor上创建一个Project：
之后在服务器上找任意一个镜像，修改tag为Harbor的地址，并进行Push测试：
# docker tag goharbor/harbor-exporter:v2.3.2 YOUR_HARBOR_ADDRESS/kubernetes/harbor-exporter:v2.3.2
# docker push 192.168.8.202/kubernetes/harbor-exporter
The push refers to repository [192.168.8.202/kubernetes/harbor-exporter]
7c944a564b1f: Pushed
3cd80dd3cb0c: Pushed
8ac2885dd0bc: Pushed
6b9b715ecb6e: Pushed
f6e68d4c9b22: Pushed
v2.3.2: digest: sha256:a4f8a11ffaa67bcf19424b81ff389c687109598f7e72cf00c49b2cb11b4cc34f size: 1369
之后就可以在Harbor查看该镜像：
如果Kubernetes集群采用的是Containerd作为的Runtime，配置insecure-registry只需要在Containerd配置文件的mirrors下添加自己的镜像仓库地址即可：
# containerd config default> /opt/containerd/config.toml
# cd /opt/containerd/
# cp -p config.toml config.toml.org
# vi config.toml
# diff config.toml config.toml.org
# diff config.toml config.toml.org
106,107d105
< [plugins."io.containerd.grpc.v1.cri".registry.mirrors."192.168.8.202"]
< endpoint = ["http://192.168.8.202"]
# systemctl restart containerd.service
# systemctl status containerd.service
# vim /etc/containerd/config.toml
配置完成后，重启Containerd，之后进行pull测试：
# systemctl restart containerd
# ctr -n k8s.io image pull CHANGE_HERE_FOR_YOUR_HARBOR_ADDRESS/kubernetes/harbor-exporter:v2.3.2 --plain-http --user admin:Harbor12345
# ctr -n k8s.io image pull 192.168.8.202/kubernetes/harbor-exporter:v2.3.2 --plain-http --user admin:Harbor12345
至此用到的工具都已经安装完成，接下来需要做一些配置。
4.Jenkins 凭证Credentials
Harbor的账号密码、GitLab的私钥、Kubernetes的证书均使用Jenkins的Credentials管理。
配置Kubernetes证书
首先需要找到集群中的KUBECONFIG，一般是kubectl节点的~/.kube/config文件，或者是KUBECONFIG环境变量所指向的文件。
接下来只需要把证书文件放置于Jenkins的Credentials中即可。首先点击Manage Jenkins，之后点击Manage Credentials：
然后在点击Jenkins，之后点击Add Credentials：
在打开添加凭证页面时，需要将凭证类型改为Secret file：
Ø File：KUBECONFIG文件或其它加密文件；
Ø ID：该凭证的ID；
Ø Description：证书的描述。
# find / -name admin.conf
/etc/kubernetes/admin.conf
/root/.sealos/admin.conf
#
配置Harbor账号密码
对于账号密码和Key类型的凭证，配置步骤是一致的，只是选择的凭证类型不一样。接下来通过Jenkins凭证管理Harbor的账号密码。
在同样的位置点击Add Credentials：
选择类型为Username with password：
Ø Username：Harbor或者其它平台的用户名；
Ø Password：Harbor或者其它平台的密码；
Ø ID：该凭证的ID；
Ø Description：证书的描述。
配置GitLab Key
点击Add Credentials，类型选择为SSH Username with private key：
Ø Username：用户名，无强制性；
Ø Private Key：Jenkins服务器的私钥，一般位于~/.ssh/id_rsa。
5.配置Agent
通常情况下，Jenkins Slave会通过Jenkins Master节点的50000端口与之通信，所以需要开启Agent的50000端口。
点击Manage Jenkins，然后点击Configure Global Security：
在安全配置下方找到Agents，点击Fixed，输入50000即可：
实际使用时，没有必要把整个Kubernetes集群的节点都充当创建Jenkins Slave Pod的节点，可以选择任意的一个或多个节点作为创建Slave Pod的节点。
假设k8s-node01作为Slave节点：
# kubectl label node k8snode1 build=true
node/k8snode1 labeled
如果集群并非使用Docker作为Runtime，但是由于构建镜像时，需要使用Docker，所以该节点需要安装Docker：
# yum install -y yum-utils device-mapper-persistent-data lvm2
# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# sed -i -e '/mirrors.cloud.aliyuncs.com/d' -e '/mirrors.aliyuncs.com/d' /etc/yum.repos.d/CentOS-Base.repo
# yum install docker-ce-19.03.* docker-ce-cli-19.03.* -y
# systemctl daemon-reload && systemctl enable --now docker
如果镜像仓库未配置证书，需要配置insecure-registry：
# cat /etc/docker/daemon.json
{
"exec-opts": ["native.cgroupdriver=systemd"],
"insecure-registries": ["CHANGE_HERE_FOR_YOUR_HARBOR_ADDRESS"] # 添加此行
}
# cp -p /usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service.bak
# vi /usr/lib/systemd/system/docker.service
# diff /usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service.bak
14c14
< ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --insecure-registry=192.168.8.202
---
> ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
# systemctl daemon-reload
# systemctl restart docker
登录测试：
# docker login YOUR_HARBOR_ADDRES
Username: admin
Password:
...
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
6.Jenkins配置Kubernetes多集群
首先点击Manage Jenkins，之后点击Configure Clouds：
点击Add a new cloud，选择Kubernetes：
之后在Name字段，输入集群的名称，一般按照可识别的名称即可，比如现在是学习环境的Kubernetes可以叫做“kubernetes-study”。之后点击Kubernetes Cloud details：
然后在Credentials处选择之前添加Kubernetes证书，选择后点击Test Connection，最后在凭证下方即可看到能否正常连接的结果：
最后点击Save即可，添加完Kubernetes后，在Jenkinsfile的Agent中，就可以选择该集群作为创建Slave的集群。
如果想要添加多个集群，重复上述的步骤即可。首先添加Kubernetes凭证，然后添加Cloud即可。
Jenkins docker中添加/etc/hosts配置
# docker ps
# docker exec -it -u root jenkins bash
root用户进入
# echo "192.168.8.100 apiserver.cluster.local" >> /etc/hosts
# echo "192.168.8.100 k8smaster" >> /etc/hosts
# echo "192.168.8.200 k8snode1" >> /etc/hosts
# echo "192.168.8.201 k8snode2" >> /etc/hosts
# echo "192.168.8.202 Jenkins" >> /etc/hosts
# echo "192.168.8.203 gitlab" >> /etc/hosts
如此，解决了连通性问题
