k8s Devops-01

课时1：Jenkins自动构建介绍

课时2：Jenkins及插件安装

课时3：Jenkins声明式流水线入门

课时4：Jenkins变量使用

课时5：Jenkins级联变量

课时6：镜像仓库配置

课时7：Gitlab安装配置

课时8：Jenkins Credentials使用

课时9：Jenkins BlueOcean

课时10：Jenkins自动构建流水线设计

Jenkins自动构建介绍

持续集成：帮助开发人员更加频繁的将代码合并到共享分支或主干中，合并之后会自动触发构建应用，运行不同级别的代码扫描（sonarqube）和自动化测试（单元和集成测试）。

持续交付：将通过集成测试的代码合并到一个可以随时部署到生产环境的代码库。

持续部署：持续交付的延伸，就是将代码自动发布到生产环境中。

两重类型：

自动构建流水线，需要构建和编译
无需构建，选择镜像发版

Jenkins及插件安装

安装jdk1.8，参考https://developer.aliyun.com/article/947906

注：（2.414.2版本需要安装jdk11及以上版本参考配置：https://developer.aliyun.com/article/913743）

详细版本参考jenkins war包网站：

Jenkins war包安装：http://mirrors.jenkins.io/war-stable/

~~wget https://mirrors.jenkins.io/war-stable/2.222.4/jenkins.war~~

~~wget https://mirrors.jenkins.io/war-stable/2.346.3/jenkins.war~~

wget https://mirrors.jenkins.io/war-stable/2.414.2/jenkins.war

java -jar jenkins.war --httpPort=28080

后台启动：nohup java -jar jenkins.war --httpPort=28080 &

成功启动后：

密码可以在/root/.jenkins/secrets/initialAdminPassword中找到

因为插件安装时间较长，这里我们不选择了（全部点成空），之后自己安装已经下载好的较为全面的插件

设置一个管理员密码后，就可以登陆了

停止jenkins，安装插件

安装插件：链接: https://pan.baidu.com/s/1x5Azx6z2v2Kx8M1xoDIPoA 提取码: me2n
plugins-2.277.tar.gz

tar -xvf plugins-2.277.tar.gz -C /opt/jenkins-plugins

cd /root/.jenkins/plugins && mv /opt/jenkins-plugins/* .

插件更新之前jenkins一定要备份，否则可能会导致插件更新后jekins无法正常启动

重新后台启动jenkins：
nohup java -jar jenkins.war --httpPort=28080 &

更新jenkins版本后，部分插件需要适配更新或被废除，更新到最新版本自动重启jenkins即可

Jenkins声明式流水线入门

Jenkins pipeline语法：https://www.jenkins.io/doc/book/pipeline/syntax/

中文文档(推荐)：https://www.jenkins.io/zh/doc/book/pipeline/syntax/

声明式流水线是最近添加到 Jenkins 流水线的，它在流水线子系统之上提供了一种更简单，更有主见的语法。

所有有效的声明式流水线必须包含在一个 pipeline 块中, 比如:

pipeline {
    /* insert Declarative Pipeline here */
}

代理

agent 部分指定了整个流水线或特定的部分, 将会在Jenkins环境中执行的位置，这取决于 agent 区域的位置。该部分必须在 pipeline 块的顶层被定义, 但是 stage 级别的使用是可选的。

参数

为了支持作者可能有的各种各样的用例流水线, agent 部分支持一些不同类型的参数。这些参数应用在`pipeline`块的顶层, 或 stage 指令内部。

any

在任何可用的代理上执行流水线或阶段。例如: agent any

none

当在 pipeline 块的顶部没有全局代理，该参数将会被分配到整个流水线的运行中并且每个 stage 部分都需要包含他自己的 agent 部分。比如: agent none

label

在提供了标签的 Jenkins 环境中可用的代理上执行流水线或阶段。例如: agent { label 'my-defined-label' }

node

agent { node { label 'labelName' } } 和 agent { label 'labelName' } 一样, 但是 node 允许额外的选项 (比如 customWorkspace )。

docker

使用给定的容器执行流水线或阶段。该容器将在预置的 node上，或在匹配可选定义的`label` 参数上，动态的供应来接受基于Docker的流水线。 docker 也可以选择的接受 args 参数，该参数可能包含直接传递到 docker run 调用的参数, 以及 alwaysPull 选项, 该选项强制 docker pull ，即使镜像名称已经存在。比如: agent { docker 'maven:3-alpine' } 或

agent {
    docker {
        image 'maven:3-alpine'
        label 'my-defined-label'
        args  '-v /tmp:/tmp'
    }
}

dockerfile（构建过程较慢）

执行流水线或阶段, 使用从源代码库包含的 Dockerfile 构建的容器。为了使用该选项， Jenkinsfile 必须从多个分支流水线中加载, 或者加载 "Pipeline from SCM." 通常，这是源代码仓库的根目录下的 Dockerfile : agent { dockerfile true }. 如果在另一个目录下构建 Dockerfile , 使用 dir 选项: agent { dockerfile {dir 'someSubDir' } }。如果 Dockerfile 有另一个名称, 你可以使用 filename 选项指定该文件名。你可以传递额外的参数到 docker build ... 使用 additionalBuildArgs 选项提交, 比如 agent { dockerfile {additionalBuildArgs '--build-arg foo=bar' } }。例如, 一个带有 build/Dockerfile.build 的仓库,期望一个构建参数 version:

agent {
    // Equivalent to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/
    dockerfile {
        filename 'Dockerfile.build'
        dir 'build'
        label 'my-defined-label'
        additionalBuildArgs  '--build-arg version=1.0.2'
    }
}

常见选项

有一些应用于两个或更多 agent 的实现的选项。他们不被要求，除非特别规定。

label

一个字符串。该标签用于运行流水线或个别的 stage。

该选项对 node, docker 和 dockerfile 可用, `node`要求必须选择该选项。

customWorkspace

一个字符串。在自定义工作区运行应用了 agent 的流水线或个别的 stage, 而不是默认值。它既可以是一个相对路径, 在这种情况下，自定义工作区会存在于节点工作区根目录下, 或者一个绝对路径。比如:

agent {
    node {
        label 'my-defined-label'
        customWorkspace '/some/other/path'
    }
}

该选项对 node, docker 和 dockerfile 有用。

reuseNode

一个布尔值, 默认为false。如果是true, 则在流水线的顶层指定的节点上运行该容器, 在同样的工作区, 而不是在一个全新的节点上。

这个选项对 docker 和 dockerfile 有用, 并且只有当使用在个别的 stage 的 agent 上才会有效。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent { docker 'maven:3-alpine' } 
    stages {
        stage('Example Build') {
            steps {
                sh 'mvn -B clean verify'
            }
        }
    }
}

阶段级别的 agent 部分

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent none 
    stages {
        stage('Example Build') {
            agent { docker 'maven:3-alpine' } 
            steps {
                echo 'Hello, Maven'
                sh 'mvn --version'
            }
        }
        stage('Example Test') {
            agent { docker 'openjdk:8-jre' } 
            steps {
                echo 'Hello, JDK'
                sh 'java -version'
            }
        }
    }
}

post

post 部分定义一个或多个steps ，这些阶段根据流水线或阶段的完成情况而运行(取决于流水线中 post 部分的位置). post 支持以下 post-condition 块中的其中之一: always, changed, failure, success, unstable, 和 aborted。这些条件块允许在 post 部分的步骤的执行取决于流水线或阶段的完成状态。

Conditions

always

无论流水线或阶段的完成状态如何，都允许在 post 部分运行该步骤。

changed

只有当前流水线或阶段的完成状态与它之前的运行不同时，才允许在 post 部分运行该步骤。

failure

只有当前流水线或阶段的完成状态为"failure"，才允许在 post 部分运行该步骤, 通常web UI是红色。

success

只有当前流水线或阶段的完成状态为"success"，才允许在 post 部分运行该步骤, 通常web UI是蓝色或绿色。

unstable

只有当前流水线或阶段的完成状态为"unstable"，才允许在 post 部分运行该步骤, 通常由于测试失败,代码违规等造成。通常web UI是黄色。

aborted

只有当前流水线或阶段的完成状态为"aborted"，才允许在 post 部分运行该步骤, 通常由于流水线被手动的aborted。通常web UI是灰色。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
    post { 
        always { 
            echo 'I will always say Hello again!'
        }
    }
}

stages

包含一系列一个或多个 stage 指令, stages 部分是流水线描述的大部分"work" 的位置。建议 stages 至少包含一个 stage 指令用于连续交付过程的每个离散部分,比如构建, 测试, 和部署。

steps

steps 部分在给定的 stage 指令中执行的定义了一系列的一个或多个steps。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages { 
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

指令

environment

environment 指令制定一个键-值对序列，该序列将被定义为所有步骤的环境变量，或者是特定于阶段的步骤，这取决于 environment 指令在流水线内的位置。

该指令支持一个特殊的助手方法 credentials() ，该方法可用于在Jenkins环境中通过标识符访问预定义的凭证。对于类型为 "Secret Text"的凭证, credentials() 将确保指定的环境变量包含秘密文本内容。对于类型为 "SStandard username and password"的凭证, 指定的环境变量指定为 username:password ，并且两个额外的环境变量将被自动定义 :分别为 MYVARNAME_USR 和 MYVARNAME_PSW 。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    environment { 
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment { 
                AN_ACCESS_KEY = credentials('my-prefined-secret-text') 
            }
            steps {
                sh 'printenv'
            }
        }
    }
}

顶层流水线块中使用的 environment 指令将适用于流水线中的所有步骤。

在一个 stage 中定义的 environment 指令只会将给定的环境变量应用于 stage 中的步骤。

environment 块有一个助手方法 credentials() 定义，该方法可以在 Jenkins 环境中用于通过标识符访问预定义的凭证。

options

options 指令允许从流水线内部配置特定于流水线的选项。流水线提供了许多这样的选项, 比如 buildDiscarder,但也可以由插件提供, 比如 timestamps.

可用选项

buildDiscarder

为最近的流水线运行的特定数量保存组件和控制台输出。例如: options { buildDiscarder(logRotator(numToKeepStr: '1')) }

disableConcurrentBuilds

不允许同时执行流水线。可被用来防止同时访问共享资源等。例如: options { disableConcurrentBuilds() }

overrideIndexTriggers

允许覆盖分支索引触发器的默认处理。如果分支索引触发器在多分支或组织标签中禁用, options { overrideIndexTriggers(true) } 将只允许它们用于促工作。否则, options { overrideIndexTriggers(false) } 只会禁用改作业的分支索引触发器。

skipDefaultCheckout

在`agent` 指令中，跳过从源代码控制中检出代码的默认情况。例如: options { skipDefaultCheckout() }

skipStagesAfterUnstable

一旦构建状态变得UNSTABLE，跳过该阶段。例如: options { skipStagesAfterUnstable() }checkoutToSubdirectory

在工作空间的子目录中自动地执行源代码控制检出。例如: options { checkoutToSubdirectory('foo') }

timeout

设置流水线运行的超时时间, 在此之后，Jenkins将中止流水线。例如: options { timeout(time: 1, unit: 'HOURS') }

retry

在失败时, 重新尝试整个流水线的指定次数。 For example: options { retry(3) }

timestamps

预谋所有由流水线生成的控制台输出，与该流水线发出的时间一致。例如: options { timestamps() }

Example

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    options {
        timeout(time: 1, unit: 'HOURS') 
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

参数

parameters 指令提供了一个用户在触发流水线时应该提供的参数列表。这些用户指定参数的值可通过 params 对象提供给流水线步骤

可用参数

string

字符串类型的参数, 例如: parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }

booleanParam

布尔参数, 例如: parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    parameters {
        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
    }
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}"
            }
        }
    }
}

使用案例自动生成变量

需要先Build Now构建一次，才会出现Parameters

建议变量按照第一次步骤修改在这里，不需要第一次构建，且不需要修改文件

input

stage 的 input 指令允许你使用 input step提示输入。在应用了 options 后，进入 stage 的 agent 或评估 when 条件前， stage 将暂停。如果 input 被批准, stage 将会继续。作为 input 提交的一部分的任何参数都将在环境中用于其他 stage。

配置项

message

必需的。这将在用户提交 input 时呈现给用户。

input 的可选标识符，默认为 stage 名称。

`input`表单上的"ok" 按钮的可选文本。

submitter

可选的以逗号分隔的用户列表或允许提交 input 的外部组名。默认允许任何用户。

submitterParameter

环境变量的可选名称。如果存在，用 submitter 名称设置。parameters

提示提交者提供的一个可选的参数列表。更多信息参见 [parameters]。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    options {
        timeout(time: 10, unit: 'SECONDS') 
    }
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "alice,bob"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

如果超过10秒不点击，则超时

input中可以在Deployment中手动选择参数，但是此步骤如果一直等待，可以使用options{ timeout }方式延时进行

when

when 指令允许流水线根据给定的条件决定是否应该执行阶段。 when 指令必须包含至少一个条件。如果 when 指令包含多个条件, 所有的子条件必须返回True，阶段才能执行。这与子条件在 allOf 条件下嵌套的情况相同。

使用诸如 not, allOf, 或 anyOf 的嵌套条件可以构建更复杂的条件结构 can be built 嵌套条件可以嵌套到任意深度。

内置条件

branch

当正在构建的分支与模式给定的分支匹配时，执行这个阶段, 例如: when { branch 'master' }。注意，这只适用于多分支流水线。

environment

当指定的环境变量是给定的值时，执行这个步骤, 例如: when { environment name: 'DEPLOY_TO', value: 'production' }

expression

当指定的Groovy表达式评估为true时，执行这个阶段, 例如: when { expression { return params.DEBUG_BUILD } }

not

当嵌套条件是错误时，执行这个阶段,必须包含一个条件，例如: when { not { branch 'master' } }allOf

当所有的嵌套条件都正确时，执行这个阶段,必须包含至少一个条件，例如: when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }

anyOf

当至少有一个嵌套条件为真时，执行这个阶段,必须包含至少一个条件，例如: when { anyOf { branch 'master'; branch 'staging' } }

在进入 stage 的 agent 前评估 when

默认情况下, 如果定义了某个阶段的代理，在进入该`stage` 的 agent 后该 stage 的 when 条件将会被评估。但是, 可以通过在 when 块中指定 beforeAgent 选项来更改此选项。如果 beforeAgent 被设置为 true, 那么就会首先对 when 条件进行评估 , 并且只有在 when 条件验证为真时才会进入 agent 。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
                environment name: 'DEPLOY_TO', value: 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                allOf {
                    branch 'production'
                    environment name: 'DEPLOY_TO', value: 'production'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
                anyOf {
                    environment name: 'DEPLOY_TO', value: 'production'
                    environment name: 'DEPLOY_TO', value: 'staging'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                expression { BRANCH_NAME ==~ /(production|staging)/ }
                anyOf {
                    environment name: 'DEPLOY_TO', value: 'production'
                    environment name: 'DEPLOY_TO', value: 'staging'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            agent {
                label "some-label"
            }
            when {
                beforeAgent true
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

并行

声明式流水线的阶段可以在他们内部声明多隔嵌套阶段, 它们将并行执行。注意，一个阶段必须只有一个 steps 或 parallel 的阶段。嵌套阶段本身不能包含进一步的 parallel 阶段, 但是其他的阶段的行为与任何其他 stage 相同。任何包含 parallel 的阶段不能包含 agent 或 tools 阶段, 因为他们没有相关 steps。

另外, 通过添加 failFast true 到包含 parallel`的 `stage 中，当其中一个进程失败时，你可以强制所有的 parallel 阶段都被终止。

示例

Jenkinsfile (Declarative Pipeline)

pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            failFast true
            parallel {
                stage('Branch A') {
                    agent {
                        label "for-branch-a"
                    }
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent {
                        label "for-branch-b"
                    }
                    steps {
                        echo "On Branch B"
                    }
                }
            }
        }
    }
}

Jenkins变量使用

新建一个流水线任务

打印出jenkins的默认变量

常用的一些内置变量：

JENKINS_URL=http://192.168.1.11:28080/
BUILD_ID=1
HOSTNAME=k8s-master02
BUILD_NUMBER=1
BUILD_URL=http://192.168.1.11:28080/job/pipeline-var/1/
JOB_NAME=pipeline-var
JOB_URL=http://192.168.1.11:28080/job/pipeline-var/

自定义变量：

继续添加参数，list分支

匹配refs/heads/后面的值

Hidden Parameter、String Parameter，直接指定参数即可

尝试构建：

Jenkins级联变量

参考文档：

Jenkins Active Choice parameter：https://plugins.jenkins.io/uno-choice/

创建一个新任务

添加一个Active Choices Parameter，参数如果需要默认勾选，可以修改成return['test1:selected','test2','test3']形式

默认是下拉选择，可以修改成Choice Type为使用单选框或多选框，如果选择过多，可以使用Enable filters进行过滤

添加一个参考参数：

if (TEST_ENV.equals('test1')) {
    return ['test1-image1','test1-image2']
} else if (TEST_ENV.equals('test2')) {
    return ['test2-image1','test2-image2']
} else if (TEST_ENV.equals('test3')) {
    return ['no image']
}

测试结果：

镜像仓库配置

这里容器镜像使用阿里云容器镜像

阿里云镜像仓库：https://cr.console.aliyun.com/cn-beijing/instances/namespaces

阿里云的命令空间：对应的就是harbor的repository Repository下有镜像等同于阿里云的镜像仓库

linux还需要安装下阿里云客户端工具(和jenkins安装在同一台机器上，如果是dockerhub仓库使用curl即可获取，不需要安装客户端工具)：https://help.aliyun.com/document_detail/121541.html

mkdir $HOME/aliyun && cd  $HOME/aliyun
wget https://aliyuncli.alicdn.com/aliyun-cli-linux-3.0.73-amd64.tgz #不要安装新版本，新版本aliyun-cli只支持企业级仓库配置
tar xzvf aliyun-cli-linux-3.0.73-amd64.tgz
sudo cp aliyun /usr/local/bin

在云平台申请一个AK

获取ak，使用阿里云客户端进行配置

aliyun configure

等会需要指定RepoNamespace和RepoName如下图展示

aliyun cr GetRepoTags --RepoNamespace=howell-kubernetes --RepoName=efk

使用jq语法获取镜像tag

aliyun cr GetRepoTags --RepoNamespace=howell-kubernetes --RepoName=efk | jq ".data.tags[].tag" -r

Gitlab安装配置

Gitlab 下载地址：

https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/
https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el8/

安装

wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/gitlab-ce-13.0.3-ce.0.el7.x86_64.rpm
yum -y install gitlab-ce-13.0.3-ce.0.el7.x86_64.rpm

修改配置：

vim /etc/gitlab/gitlab.rb

gitlab-ctl reconfigure

启动后停止一些不必要的服务

gitlab-ctl stop gitlab-exporter

gitlab-ctl stop grafana

gitlab-ctl stop prometheus

修改hosts：

登陆

导入master01公钥

创建一个组kubernetes-guide：

修改下hosts，然后git下来，将我们之前的spring-cloud-demo2项目考过去

git clone git@gitlab.test.com:kubernetes-guide/spring-cloud-demo.git
cp -rp spring-cloud-demo2/* spring-cloud-demo

根据部署平台进行登陆配置

cd spring-cloud-demo
git config --global user.email "admin@example.com"
git config --global user.name "root"

根据gitlab推送命令推送项目

git add .
git commit -m "Initial commit"
git push -u origin master

查看项目

关掉全局和项目的Auto DevOps

如果想要单个项目授权（非管理员的情况）

需要将我们jenkins构建的用户权限添加进来

Jenkins Credentials使用

在gitlab上添加私钥，开通整个gitlab权限

jenkins上添加凭证

阿里云镜像仓库

gitlab ssh凭证

这个ID之后会用到

测试下gitlab凭证是否可用

复制下项目地址

成功获取到项目的分支

Jenkins BlueOcean

Jenkins BlueOcean提供了更直观的构建界面，并且可以指定阶段运行流水线以及编辑流水线和创建流水线

在gitlab组中创建一个新的project

github方式：

可以编辑流水线，在流水线中使用groovy和shell以及sleep等方式，并且支持并行流程，最后保存

gitlab自动生成jenkinsfile

pipeline {
  agent any
  stages {
    stage('test stages') {
      parallel {
        stage('test stages') {
          steps {
            sh 'echo "step 1"'
          }
        }

        stage('test stages2') {
          steps {
            sleep 3
          }
        }

      }
    }

    stage('test stages2') {
      steps {
        echo 'step2'
      }
    }

    stage('build') {
      steps {
        sh 'echo "start building"'
      }
    }

  }
}

执行完后进入可以看清每个stage的步骤日志

如果有报错，可以重新编辑修改流水线

使用BlueOcean写好之后，一般在jenkins中新建job去引用BlueOcean所创建的jenkins项目

如下图为gitlab-test项目引用BlueOcean，使用建议：使用BlueOcean创建一个gitlab的项目，然后新建job引用gitlab项目中的jenkinsfile即可，jenkinsfile进行统一管理，可以更好的管理gitlab中的多个项目

BlueOcean调用另外的job

如果需要更新，修改初始创建的jenkinsfile（只有这个项目可以使用BlueOcean编辑）

调用build a job 功能

Jenkins自动构建流水线设计

代码仓库创建你们的项目
开发去开发代码逻辑
Push到gitlab后执行构建
1. 自动构建
  1. Env.gitlabBranch
1. 手动构建
  1. BRANCH
1. 定时构建
Jenkins调用k8s创建Pod执行构建
1. 代码编译
1. 代码扫描
根据Dockerfile生成我们的镜像
1. 放在对应项目的根目录下
  1. TAG
  1. Dockerfile –>项目根目录
  1. Harbor地址
  1. Harbor registry
  1. 应用名称
1. 放在gitlab统一管理
1. 每个job配置单独的变量
  1. Jar、war -> 基础镜像
  1. Html -> html/
  1. .-> 工作目录 node server.js
    1. COPY 参数化
Push镜像到镜像仓库
Jenkins Slave kubectl -> set 命令更新我们的镜像
1. 只更新镜像
1. Helm更新
判断程序是否启动
1. -w
1. 写脚本去判断
程序启动后，调用测试Job

不构建的流水线：

Jenkins调用镜像仓库接口，返回镜像tag
选择对于的tag进行发版到其他环境

发布者：LJH，转发请注明出处：https://www.ljh.cool/38202.html

k8s Devops-01

Jenkins自动构建介绍

Jenkins及插件安装

Jenkins声明式流水线入门

environment

可用选项

Example

可用参数

示例

示例

Jenkins变量使用

Jenkins级联变量

镜像仓库配置

Gitlab安装配置

Jenkins Credentials使用

Jenkins BlueOcean

Jenkins自动构建流水线设计

相关推荐

4-Maven项目构建

k8s Devops-02

2-github&gitlab

5-pipeline和代码上线

3-jenkins

1-git