Akemi

DevOps工具链

2024/05/06

如果出现无法载图的情况，请检查与github的连通性

DevOps基础概念

1.敏捷开发
提高开发效率，及时跟进用户需求
包括编写代码和构建代码两个阶段，可以用git或svn来管理代码，通过maven进行构建

2.持续集成CI
强调提交了开发提交新代码后，立刻进行构建与（自动化）测试，来判断新代码能否与原有代码集成在一起
常用工具：
Jenkins-最流行的持续集成工具，可以自动检测git和svn存储库的更新，基于最新代码进行构建，并发布到生产环境；并且支持在多台机器上分布式构建和负载测试；支持和k8s对接
TeamCity、TravisCI、Go CD、Bamboo、GitLab CI、Codeship等

优势：较早发现错误，快速发现错误，提升团队绩效，防止分支过多偏离主干（频繁合并到主干）
核心措施：代码自动化测试，集成到主干

3.持续交付CD
在持续集成的基础上，将集成后的代码部署到更贴近真实运行环境的预生产环境（有些直接到生产环境），交付给质量团队或用户评审，如果评审通过就进入生产阶段。
如果一次交付，就会发现很多问题；持续交付就是每次更新都交付一次，及时发现问题并解决

4.持续部署
当代码通过评审时，自动部署到生产环境，持续部署是持续交付的最高阶段。
常用工具有Puppet，SaltStack，ansible；现在也可以用docker，k8s

Jenkins

有正常部署、容器化部署、k8s部署三种方式。因为前两种过于简单，所以只着重介绍第三种方式

jenkins部署

环境：
k8s版本v1.28.1
Jenkins版本（最新版）2.452
centos7.9
192.168.10.121 ws-k8s-master1
192.168.10.122 ws-k8s-master2
192.168.10.123 ws-k8s-master3
192.168.10.130 harbor
192.168.10.131 ws-k8s-node1
192.168.10.132 ws-k8s-node2
192.168.10.133 ws-k8s-node3

环境准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#镜像加速器
cat > /etc/docker/daemon.json << EOF 
{
"registry-mirrors": [
"https://hub-mirror.c.163.com",
"https://docker.m.daocloud.io",
"https://ghcr.io",
"https://mirror.baidubce.com",
"https://docker.nju.edu.cn"],
"exec-opts": ["native.cgroupdriver=systemd"],
"insecure-registries": ["192.168.10.130","harbor"]
}
EOF
systemctl daemon-reload
systemctl restart docker

#镜像导入node节点
docker pull jenkins:latest
docker save jenkins:latest -o jenkins.latest.tar.gz
ctr -n=k8s.io image import jenkins.latest.tar.gz

mkdir jenkins
cd jenkins

#每个节点安装nfs
yum -y install nfs-utils && systemctl enable nfs-server.service --now

#master1配置nfs,创建共享的目录
mkdir -p /data/v1
mkdir -p /data/v2
cat > /etc/exports << EOF
/data/v1 *(rw,no_root_squash)
/data/v2 *(rw,no_root_squash)
EOF
exportfs -arv


#部署Jenkins
kubectl create namespace jenkins-k8s
#在ns中创建一个pv与pvc
cat > pv.yaml << EOF
apiVersion: v1
kind: PersistentVolume
metadata:
  name: jenkins-k8s-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
  - ReadWriteMany
  nfs:
    server: 192.168.10.121
    path: /data/v2
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: jenkins-k8s-pvc
  namespace: jenkins-k8s
spec:
  resources:
    requests:
      storage: 10Gi
  accessModes:
  - ReadWriteMany
EOF
kubectl get pv -n jenkins-k8s
NAME             CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                         STORAGECLASS   REASON   AGE
jenkins-k8s-pv   10Gi       RWX            Retain           Bound    jenkins-k8s/jenkins-k8s-pvc                           42s
#创建sa，并且授权
kubectl create sa jenkins-k8s-sa -n jenkins-k8s
kubectl create clusterrolebinding jenkins-k8s-sa-cluster -n jenkins-k8s \
--clusterrole=cluster-admin --serviceaccount=jenkins-k8s:jenkins-k8s-sa

#准备镜像
#jenkins-slave
ctr -n=k8s.io image import jenkins-slave-latest.tar.gz

jenkins-slave用以让jenkins能够对接k8s，使用k8s中的资源：
开发代码->提交代码到代码仓库->Jenkins调k8s API->动态生成Jenkins Slave Pod->Slave Pod拉取git上的代码->编译代码->打包镜像->推送镜像到镜像仓库harbor或者docker hub->通过k8s编排服务发布到测试、生产平台-> Slave Pod工作完成之后自动删除>通过Ingress发布服务
jenkins-slave制作
dockerfile

1
2
3
4
5
6
7
8
9
FROM jenkins/jnlp-slave:latest
USER root
RUN apt-get update && apt-get install -y docker.io
RUN usermod -aG docker jenkins
RUN curl -LO https://dl.k8s.io/release/stable.txt
RUN curl -LO https://dl.k8s.io/release/$(cat stable.txt)/bin/linux/amd64/kubectl
RUN chmod +x kubectl
RUN mv kubectl /usr/local/bin/
ENV DOCKER_HOST unix:///var/run/docker.sock

部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
jenkins-deployment.yaml
kind: Deployment
apiVersion: apps/v1
metadata:
  name: jenkins
  namespace: jenkins-k8s
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins
  template:
    metadata:
      labels:
        app: jenkins
    spec:
      serviceAccount: jenkins-k8s-sa
      containers:
      - name: jenkins
        image:  jenkins/jenkins:2.328
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080
          name: web
          protocol: TCP
        - containerPort: 50000
          name: agent
          protocol: TCP
        resources:
          limits:
            cpu: 2000m
            memory: 2Gi
          requests:
            cpu: 500m
            memory: 512Mi
        livenessProbe:
          httpGet:
            path: /login
            port: 8080
          initialDelaySeconds: 60
          timeoutSeconds: 5
          failureThreshold: 12
        readinessProbe:
          httpGet:
            path: /login
            port: 8080
          initialDelaySeconds: 60
          timeoutSeconds: 5
          failureThreshold: 12
        volumeMounts:
        - name: jenkins-volume
          subPath: jenkins-home
          mountPath: /var/jenkins_home
      volumes:
      - name: jenkins-volume
        persistentVolumeClaim:
          claimName: jenkins-k8s-pvc

chown -R 1000.1000 /data/v2
kubectl apply -f jenkins-deployment.yaml

#创建对应的service
cat > jenkins-service.yaml << EOF
apiVersion: v1
kind: Service
metadata:
  name: jenkins-service
  namespace: jenkins-k8s
  labels:
    app: jenkins
spec:
  selector:
    app: jenkins
  type: NodePort
  ports:
  - name: web
    port: 8080
    targetPort: web
    nodePort: 30002
  - name: agent
    port: 50000
    targetPort: agent
EOF
kubectl apply -f jenkins-service.yaml

web访问http://192.168.10.200:30002/
使用管理员密码登录
cat /var/jenkins_home/secrets/initialAdminPassword

按推荐插件安装
创建管理员用户admin
→保存并完成

修改密码方法：
jenkins-home/users/admin/config.xml
修改 #jbcrypt:$2a$10$tbcOE9WRKp7wlsH/5x.l0.zFnzyTQqiFcrvGE32WwWrdrXaSwUJa2

报错Signature verification failed in update site ‘default’ (show details)：
修改升级源
https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json
重启jenkins

常用插件：
推荐插件+ blueocean+ kubernetes+ locale(汉化)
gitlab插件：

Jenkins对接k8s

jenkins对接k8s，生成slave节点

1.jenkins添加k8s
进入系统管理http://apiserver:30002/configureClouds/
选择添加一个新的k8s云环境
填写云环境基本信息:
k8s地址https://192.168.10.200:6443

jenkins地址：
http://jenkins-service.jenkins-k8s.svc.cluster.local:8080

  1. 填写pod templates:
    名称jnlp
    container标签要写自己能记住的，我写wangsheng，因为写pipeline的时候node需要指定这个名字

主机挂载路径：

  • /var/run/docker.sock:/var/run/docker.sock
  • /home/.kube:/home/jenkins/.kube

将/root/.kube拷贝到工作节点
scp -r /root/.kube ws-k8s-node1:/root/
scp -r /root/.kube ws-k8s-node2:/root/
scp -r /root/.kube ws-k8s-node3:/root/

3.配置凭据
添加harbor的用户名密码
配置凭据ID需要记住，后面要用，我写的是dockerhub

  1. 测试
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    pipeline{
        agent{
            kubernetes{
                inheritFrom 'test'
                cloud 'kubernetes'
    	        }
    		    }
    		stages{
    				stage("run shell"){
    				    steps{
    						    echo "hello shell"
    							     }
    					}
    				stage("maven"){
    				    steps{
    						    sh 'mvn -version'
    						    echo 'Maven Build Success'
    					    }}
    				stage("test maven"){
    						 steps{
    				    sh 'mvn help:system'
    					   echo 'build finished'
    				    }}
    }}

从github上拉取，推送至harbor

带注释的版本，实际使用要将注释删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
node('wangsheng') { #一个node,指定template的标签
    stage('Clone') { #clone的stage
        echo "1.Clone Stage"  #拉取git
        git url: "https://github.com/Durative/jenkins-sample.git"
        script { #通过git rev-parse获取版本的tag，用来打在镜像上
            build_tag = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
        }
    }
    stage('Test') {
      echo "2.Test Stage"

    }
    stage('Build') { #构建stage
        echo "3.Build Docker Image Stage" #直接带上harbor的tag，构建镜像
        sh "docker build -t 192.168.40.132/jenkins-demo/jenkins-demo:${build_tag} ."
    }
    stage('Push') { #指定凭证，登录harbor，并且推送到harbor
        echo "4.Push Docker Image Stage"
        withCredentials([usernamePassword(credentialsId: 'dockerharbor', passwordVariable: 'dockerHubPassword', usernameVariable: 'dockerHubUser')]) {
            sh "docker login 192.168.40.132 -u ${dockerHubUser} -p ${dockerHubPassword}"
            sh "docker push 192.168.40.132/jenkins-demo/jenkins-demo:${build_tag}"
        }
    }
    stage('Deploy to dev') { #发布到dev ns
        echo "5. Deploy DEV"
		sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-dev-harbor.yaml" #替换yaml的镜像tag
        sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-dev-harbor.yaml" #修改yaml的branch
//        sh "bash running-devlopment.sh"
        sh "kubectl apply -f k8s-dev-harbor.yaml  --validate=false"
	}	
	stage('Promote to qa') {	#发布到qa ns
		def userInput = input( #选择是否要发布到qa
            id: 'userInput',

            message: 'Promote to qa?',
            parameters: [
                [
                    $class: 'ChoiceParameterDefinition',
                    choices: "YES\nNO",
                    name: 'Env'
                ]
            ]
        )
        echo "This is a deploy step to ${userInput}" #如果要发布，修改对应的qa-harbor的yaml
        if (userInput == "YES") {
            sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-qa-harbor.yaml"
            sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-qa-harbor.yaml"
//            sh "bash running-qa.sh"
            sh "kubectl apply -f k8s-qa-harbor.yaml --validate=false"
            sh "sleep 6"
            sh "kubectl get pods -n qatest"
        } else {
            //exit
        }
    }
	stage('Promote to pro') {	
		def userInput = input(

            id: 'userInput',
            message: 'Promote to pro?',
            parameters: [
                [
                    $class: 'ChoiceParameterDefinition',
                    choices: "YES\nNO",
                    name: 'Env'
                ]
            ]
        )
        echo "This is a deploy step to ${userInput}"
        if (userInput == "YES") {
            sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-prod-harbor.yaml"
            sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-prod-harbor.yaml"
//            sh "bash running-production.sh"
            sh "cat k8s-prod-harbor.yaml"
            sh "kubectl apply -f k8s-prod-harbor.yaml --record --validate=false"
        }
    }
}

pipeline

概述

Jenkins pipeline （流水线）是一套运行于jenkins上的工作流框架，将原本独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排与可视化。

它把持续提交流水线（Continuous Delivery Pipeline）的任务集成到Jenkins中。持续提交流水线就是从版本控制到提交软件、变更、发布这个过程。

pipeline脚本是由groovy语言实现
支持两种语法：声明式、脚本式

声明式Declarative

声明式pipeline流程与举例

声明式pipeline语法包括以下核心流程：

1.pipeline : 声明其内容为一个声明式的pipeline脚本
2.agent:  执行节点（job运行的slave或者master节点）
none 不指定运行节点，由stage决定
any 可运行在任意节点上
3.stages: 阶段集合，包裹所有的阶段（例如：打包，部署等各个阶段）
4.stage:  阶段，被stages包裹，一个stages可以有多个stage
5.steps:  步骤,为每个阶段的最小执行单元,被stage包裹
6.post:   执行构建后的操作，根据构建结果来执行对应的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
pipeline{ #作用域，表示是声明式语法
    agent any #作用域，表示接下来的任务可以在any节点上执行
    stages{
        stage("This is first stage"){
            steps("This is first step"){
                echo "I am wangsheng"
            }
        }
    }
    post{
        always{
            echo "The process is ending"
        }
    }
}
========================================================
agent { 
     node {
         label  'my-defined-label'
         customWorkspace 'xxxxxxx'
    } 
}
#node{ label 'master'} 和agent { label 'master' }一样，但是node可以扩展节点信息，允许额外的选项 (比如 customWorkspace )。

agent { docker 'python'  }
#使用指定的容器运行流水线
如：
agent {
    docker {
        image 'maven:3-alpine'
        label 'my-defined-label'
        args  '-v /tmp:/tmp'
    }
}
#定义此参数时，执行Pipeline或stage时会动态的在具有label 'my-defined-label'标签的node提供docker节点去执行Pipelines。 docker还可以接受一个args，直接传递给docker run调用。

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'
    }
}

声明式语法关键字

environment-环境变量

一系列键值对，将被定义为所有step或stage-specific step的环境变量

1
2
3
4
5
6
7
8
9
10
11
12
13
pipeline {
    agent any
    environment {  
        CC = 'clang' 
    }
    stages {
        stage('Example') {
            steps {
                sh 'printenv'
            }
        }
    }
}

options-选项

pipeline本身配置的pipeline的专用选项

可用选项：
buildDiscarder：pipeline保持构建的最大个数。用于保存Pipeline最近几次运行的数据，例如：options { buildDiscarder(logRotator(numToKeepStr: ‘1’)) } 　　
disableConcurrentBuilds：不允许并行执行Pipeline，可用于防止同时访问共享资源等。例如：options { disableConcurrentBuilds() }
skipDefaultCheckout：跳过默认设置的代码check out。例如：options { skipDefaultCheckout() }
skipStagesAfterUnstable： 一旦构建状态进入了“Unstable”状态，就跳过此stage。例如：options { skipStagesAfterUnstable() }
timeout： 设置Pipeline运行的超时时间，超过超时时间，job会自动被终止，例如：options { timeout(time: 1, unit: ‘HOURS’) }
retry：失败后，重试整个Pipeline的次数。例如：options { retry(3) }
timestamps： 预定义由Pipeline生成的所有控制台输出时间。例如：options { timestamps() }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pipeline {
    agent any
    options {
        timeout(time: 1, unit: 'HOURS')
        retry(3)
        skipStagesAfterUnstable()
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

parameters-参数列表

parameters指令提供用户在触发Pipeline时的参数列表。这些参数值通过该params对象可用于Pipeline stag。支持[booleanParam, choice, credentials, file, text, password, run, string]这几种参数类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pipeline{
    agent any
    parameters {
        string(name: 'xianchao', defaultValue: 'my name is xianchao', description: 'My name is xiancaho')
        booleanParam(name: 'luckylucky421302', defaultValue: true, description: 'This is my wechat')
    }
    stages{
        stage("stage1"){
            steps{
                echo "$xianchao"
                echo "$luckylucky421302"
            }
        }
    }
}

指定了默认值，（选择基于参数构建）如果要不同的可以通过手动改，然后输出

triggers-触发器

用在pipeline中，定义自动化触发的方式，支持三种触发器
cron（固定周期触发）
pollSCM（检查SCM源更改的常规间隔。如果检查存在更改，则pipeline被重新出发，例如triggers { pollSCM(‘H 4/* 0 0 1-5’) }

1
2
3
4
5
6
7
8
9
10
11
12
13
pipeline {
    agent any
    triggers {
        cron('H 4/* 0 0 1-5')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

tools-指定所使用工具

通过tools可以自动化安装工具，并且放置环境变量
可支持工具：1.maven 2.jdk 3.gradle
通过tools可自动安装工具，并放置环境变量到PATH。如果agent none，这将被忽略。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Supported Tools(Global Tool Configuration)
　　maven
　　jdk
　　gradle

pipeline {
    agent any
    tools {
       #工具名称必须在Jenkins 管理Jenkins → 全局工具配置中预配置。
        maven 'apache-maven-3.0.1'
    }
    stages {
        stage('Example') {
            steps {
                sh 'mvn --version'
            }
        }
    }
}

input-赋值

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

input可以的配置项：
1.message
必需的。 这将在用户提交 input 时呈现给用户。

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

3.ok
input表单上的”ok” 按钮的可选文本。

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

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

6.parameters
提示提交者提供的一个可选的参数列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?" #信息
                ok "Yes, we should." #选项ok的值
                submitter "xianchao,lucky" #默认的输入
                parameters {
                    string(name: 'PERSON', defaultValue: 'xianchao', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

when判断

when是在stage阶段去判断的。
when指令允许Pipeline根据给定的条件确定是否执行该阶段。该when指令必须至少包含一个条件。如果when指令包含多个条件，则所有子条件必须为stage执行返回true

内置条件
branch
当正在构建的分支与给出的分支模式匹配时执行，例如：when { branch ‘master’ }。请注意，这仅适用于多分支Pipeline。

environment
当指定的环境变量设置为给定值时执行，例如： when { environment name: ‘DEPLOY_TO’, value: ‘production’ }

expression
当指定的Groovy表达式求值为true时执行，例如： when { expression { return params.DEBUG_BUILD } }

not
当嵌套条件为false时执行。必须包含一个条件。例如：when { not { branch ‘master’ } }

allOf
当所有嵌套条件都为真时执行。必须至少包含一个条件。例如：when { allOf { branch ‘master’; environment name: ‘DEPLOY_TO’, value: ‘production’ } }

anyOf
当至少一个嵌套条件为真时执行。必须至少包含一个条件。例如：when { anyOf { branch ‘master’; branch ‘staging’ } }

举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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'
            }
        }
    }
}

Parallel并行执行

例子：

第一个stages没有使用parallel
第二个stages使用了parallel并行执行两个操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            parallel {
                stage('Branch A') {
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    steps {
                        echo "On Branch B"
                    }
                }
            }
        }
    }
}

可以看到后面两个步骤占用同个时间段

脚本式pipeline scripted

Groovy脚本不一定适合所有使用者，因此jenkins创建了Declarative pipeline，为编写Jenkins管道提供了一种更简单、更有主见的语法。但是由于脚本化的pipeline是基于groovy的一种DSL语言，所以与Declarative pipeline相比为jenkins用户提供了更巨大的灵活性和可扩展性。

　pipeline脚本同其它脚本语言一样，从上至下顺序执行，它的流程控制取决于Groovy表达式，如if/else条件语句，举例如下：

1
2
3
4
5
6
7
8
9
node {
    stage('Example') {
        if (env.BRANCH_NAME == 'master') {
            echo 'I only execute on the master branch'
        } else {
            echo 'I execute elsewhere'
        }
    }
}

共同点：
　　两者都是pipeline代码的持久实现，都能够使用pipeline内置的插件或者插件提供的stage，两者都可以利用共享库扩展。

不同点：
　　两者不同之处在于语法和灵活性。Declarative pipeline对用户来说，语法更严格，有固定的组织结构，更容易生成代码段，使其成为用户更理想的选择。但是Scripted pipeline更加灵活，因为Groovy本身只能对结构和语法进行限制，对于更复杂的pipeline来说，用户可以根据自己的业务进行灵活的实现和扩展。

nexus私服部署

Nexus服务器是一个代码包管理的服务器，可以理解 Nexus 服务器是一个巨大的 Library 仓库。Nexus 可以支持管理的工具包括 Maven ， npm 等，对于 JAVA 开发来说，只要用到 Maven 管理就可以了。
Nexus服务器作用：因为传统的中央仓库在国外，其地理位置比较远，下载速度比较缓慢。因此，当公司开发人员数量越来越多时，如果不架设一台自己的Nexus服务器，会产生大量的流量阻塞带宽，并且在出现一些不可抗原因（光缆被挖断）导致无法连接到中央仓库时，开发就会因为无法下载相关依赖包而进度停滞。因此在本地环境部署一台私有的Nexus服务器来缓存所有依赖包，并且将公司内部开发的私有包也部署上去，方便其他开发人员下载，是非常有必要的。因为 Nexus 有权限控制，因此外部人员是无法得到公司内部开发的项目包的。

我直接在1panel节点上部署了

1
docker run -d -p 8081:8081 -p 8082:8082 -p 8083:8083 -v /etc/localtime:/etc/localtime --name nexus3   sonatype/nexus3

http://host:8081
以下两个文件一般是开发 管理的

1.在 pom.xml 文件中声明发布的宿主仓库和 release 版本发布的仓库。
添加

<distributionManagement>
    <repository>
        <id>releases</id>
        <name>nexus-releases</name>
        <url>http://192.168.10.100:8081/repository/maven-releases/</url>
    </repository>
    <snapshotRepository>
        <id>snapshots</id>
        <name>nexus-snapshots</name>
        <url>http://192.168.10.100:8081/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>

2.在 settings.xml 文件中配置 （配置nexus用户名密码为admin 123456
由于用 Maven 分发构件到远程仓库需要认证，须要在~/.m2/settings.xml或者中加入验证信息：


public
admin
123456


releases
admin
123456


snapshots
admin
123456

对接sonarqube代码扫描工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#安装
1panel节点
docker run -d --name postgres10 -p 5432:5432 -e POSTGRES_USER=sonar -e POSTGRES_PASSWORD=123456 postgres
docker run -d --name sonarqube7.9 -p 9000:9000 --link postgres10 -e SONARQUBE_JDBC_URL=jdbc:postgresql://postgres10:5432/sonar -e SONARQUBE_JDBC_USERNAME=sonar -e SONARQUBE_JDBC_PASSWORD=123456 -v sonarqube_conf:/opt/sonarqube/conf -v sonarqube_extensions:/opt/sonarqube/extensions -v sonarqube_logs:/opt/sonarqube/logs -v sonarqube_data:/opt/sonarqube/data   sonarqube

#jenkins中安装sonarqube
搜索插件，并安装sonarqube Scanner

#登录sonarqube的web
http://1panel:9000
账号admin 密码admin

#在sonarqube生成token
administration——security——users
在tokens of administrator生成一个Generate Tokens

并且复制token
squ_f7adaf4af25b0b5423d3199c2d5420624bc62fd9

#k8s控制节点
复制microservic-test
cd /root/microservic-test
mvn sonar:sonar  -Dsonar.host.url=http://192.168.10.100:9000 -Dsonar.login=squ_f7adaf4af25b0b5423d3199c2d5420624bc62fd9

对接gitlab私有代码仓库

1
2
3
4
5
6
7
8
9
10
部署
docker run -d  -p 443:443 -p 80:80 -p 222:22 --name gitlab --restart always -v /home/gitlab/config:/etc/gitlab -v /home/gitlab/logs:/var/log/gitlab -v /home/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce

在/home/gitlab/config/gitlab.rb
增加如下三行：
external_url 'http://<IP>'
gitlab_rails['gitlab_ssh_host'] = '<IP>'
gitlab_rails['gitlab_shell_ssh_port'] = 222

docker restart gitlab

使用默认密码，根据提示cat一下即可查看

在Jenkins安装git插件,重启
添加gitlab凭据-全局凭据

jenkins创建freestyle项目，对接gitlab仓库
在jenkins里，创建密钥对
——gitlab中添加jenkins的公钥
——添加gitlab仓库地址（需要设置密钥/凭据）
——添加密钥（凭据），将私钥添加进凭据

此时已经可以连接上了，gitlab的提交参考另一篇博文gitlab

原文作者：王盛

原文链接：https://akemi.zj.cn/2024/05/06/DevOps/

发表日期：May 6th 2024, 8:09:25 pm

更新日期：February 20th 2025, 6:37:27 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

CATALOG
  1. 1. DevOps基础概念
  2. 2. Jenkins
    1. 2.1. jenkins部署
    2. 2.2. Jenkins对接k8s
      1. 2.2.1. 从github上拉取，推送至harbor
  3. 3. pipeline
    1. 3.1. 概述
    2. 3.2. 声明式Declarative
      1. 3.2.1. 声明式pipeline流程与举例
      2. 3.2.2. 声明式语法关键字
        1. 3.2.2.1. environment-环境变量
        2. 3.2.2.2. options-选项
        3. 3.2.2.3. parameters-参数列表
        4. 3.2.2.4. triggers-触发器
        5. 3.2.2.5. tools-指定所使用工具
        6. 3.2.2.6. input-赋值
        7. 3.2.2.7. when判断
        8. 3.2.2.8. Parallel并行执行
    3. 3.3. 脚本式pipeline scripted
  4. 4. nexus私服部署
  5. 5. 对接sonarqube代码扫描工具
  6. 6. 对接gitlab私有代码仓库
Total : 203
2025
2024
2023
Linux 云原生 云计算 开发 mysql