Jenkins基础教程（36）配置Jenkins 服务器之配置Kubernetes：Jenkins遇上Kubernetes：一场让CI/CD好用到“爆炸“的云原生恋爱！-优快云博客

当老牌自动化工具Jenkins遇上容器编排王者Kubernetes，CI/CD世界掀起了一场革命。这对"天作之合"不仅能帮你实现资源动态伸缩，还能让构建速度快得让团队目瞪口呆。

一、为什么你的Jenkins需要Kubernetes这个"灵魂伴侣"？

1.1 当传统Jenkins遇到现代挑战

在微服务架构普及的今天，一个中型项目可能由数十个服务组成，每个服务都需要独立的构建、测试和部署流程。传统Jenkins架构在面对这种场景时常常捉襟见肘：

资源利用率低：静态Agent在空闲时仍然占用系统资源，造成浪费
扩展不灵活：突发构建需求需要手动添加Agent，响应缓慢
环境不一致：不同Agent之间的环境差异导致构建结果不一致
维护成本高：需要单独维护每个Agent的系统依赖和工具链

1.2 Kubernetes来拯救！

Kubernetes作为容器编排的事实标准，为Jenkins带来了前所未有的弹性：

动态资源分配：Kubernetes能够根据需求动态分配资源给Jenkins Agent，实现资源的有效利用。当需求减少时，可以自动释放资源，节省了运维成本。
极致弹性：随着业务规模的扩大，可以快速地扩展Jenkins Agent的数量，以满足更多的构建需求。
环境一致性：每个构建都在全新的容器中运行，杜绝了环境差异导致的问题
简化管理：通过Kubernetes管理Jenkins Agent，可以集中管理所有Agent的配置信息。

二、准备工作：打好云原生基础

在开始之前，我们需要确保环境准备就绪。就像盖房子需要稳固的地基，Jenkins与Kubernetes的集成也需要正确的基础设置。

2.1 环境需求检查

确保你拥有以下环境：

运行中的Kubernetes集群：可以是Minikube、Kind或云服务商提供的Kubernetes服务
kubectl命令行工具：配置为可访问你的集群
网络连接：Jenkins节点需要能够访问Kubernetes API服务器

2.2 创建命名空间

为Jenkins创建独立的命名空间是个好习惯，这可以隔离资源，便于管理：

kubectl create namespace devops-tools

这个devops-tools命名空间将容纳我们所有的Jenkins资源。

三、部署Jenkins到Kubernetes：给Jenkins一个云原生的家

现在，让我们一步步将Jenkins部署到Kubernetes集群中。这将为Jenkins提供一个稳定、可靠的运行环境。

3.1 创建服务账户和权限

Jenkins需要适当的权限来管理Kubernetes资源。我们创建一个具有管理员权限的服务账户：

创建文件 jenkins-service-account.yaml：

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: jenkins-admin
rules:
  - apiGroups: [""]
    resources: ["*"]
    verbs: ["*"]
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: jenkins-admin
  namespace: devops-tools
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: jenkins-admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: jenkins-admin
subjects:
- kind: ServiceAccount
  name: jenkins-admin
  namespace: devops-tools

应用这个配置：

kubectl apply -f jenkins-service-account.yaml

这个配置创建了一个jenkins-admin集群角色、jenkins-admin服务账户，并将集群角色绑定到服务账户。

3.2 设置持久化存储

Jenkins数据不能随着Pod的重启而丢失，因此我们需要持久化存储：

创建文件 jenkins-volume.yaml：

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: jenkins-pv-volume
  labels:
    type: local
spec:
  storageClassName: local-storage
  claimRef:
    name: jenkins-pv-claim
    namespace: devops-tools
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  local:
    path: /mnt
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - worker-node01

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins-pv-claim
  namespace: devops-tools
spec:
  storageClassName: local-storage
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

注意：这个示例使用了本地存储，在生产环境中你可能需要使用云存储解决方案。

3.3 部署Jenkins控制器

现在，让我们创建Jenkins的Deployment：

创建文件 jenkins-deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
  namespace: devops-tools
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins
  template:
    metadata:
      labels:
        app: jenkins
    spec:
      serviceAccountName: jenkins-admin
      containers:
      - name: jenkins
        image: jenkins/jenkins:lts
        ports:
        - containerPort: 8080
        - containerPort: 50000
        volumeMounts:
        - name: jenkins-home
          mountPath: /var/jenkins_home
        env:
        - name: JENKINS_UC
          value: "http://updates.jenkins-ci.org"
        - name: JAVA_OPTS
          value: "-Djenkins.install.runSetupWizard=false"
      volumes:
      - name: jenkins-home
        persistentVolumeClaim:
          claimName: jenkins-pv-claim

这个部署使用了Jenkins的LTS（长期支持）版本，并配置了持久化存储卷。

3.4 暴露Jenkins服务

为了让Jenkins能够被访问，我们需要创建一个Service：

创建文件 jenkins-service.yaml：

apiVersion: v1
kind: Service
metadata:
  name: jenkins
  namespace: devops-tools
spec:
  selector:
    app: jenkins
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

应用所有配置文件：

kubectl apply -f jenkins-service-account.yaml
kubectl apply -f jenkins-volume.yaml  
kubectl apply -f jenkins-deployment.yaml
kubectl apply -f jenkins-service.yaml

等待几分钟，然后获取Jenkins服务的访问地址：

kubectl get svc -n devops-tools

四、配置Kubernetes插件：让Jenkins和K8s"牵手成功"

现在Jenkins已经在Kubernetes上运行了，接下来让我们配置Kubernetes插件，实现动态Agent管理。

4.1 安装必要插件

登录Jenkins后，首先安装以下必要插件：

Kubernetes Plugin：提供与Kubernetes集群集成的核心功能
Pipeline Plugin：允许使用Jenkinsfile定义构建流程

进入"Manage Jenkins" > "Manage Plugins"，在"Available"选项卡中搜索并安装这些插件。

4.2 配置Kubernetes云

进入"Manage Jenkins" > "Configure System"
找到"Cloud"部分，点击"Add a new cloud"，选择"Kubernetes"

现在我们需要填写Kubernetes配置：

Kubernetes URL：Kubernetes API服务器的URL。如果你在集群内部访问，可以使用https://kubernetes.default.svc.cluster.local
Kubernetes 服务证书：留空将使用默认的服务账户证书
命名空间：devops-tools
Jenkins URL：http://jenkins.devops-tools.svc.cluster.local:8080

在"Pod Templates"部分，我们需要配置一个Pod模板，用于动态创建Jenkins Agent：

名称：jenkins-agent
命名空间：devops-tools
标签：jenkins-agent
容器：点击"Add Container"

添加一个容器配置：

名称：jnlp
Docker镜像：jenkins/agent:latest
工作目录：/home/jenkins/agent
始终使用此容器运行Pod：选中

4.3 测试连接

保存配置后，我们可以测试Kubernetes连接是否正常：

进入"Manage Jenkins" > "Manage Nodes and Clouds"
点击"Build Executor Status"，你应该能看到Kubernetes相关的信息
创建一个新的Pipeline任务，在Pipeline脚本中指定使用Kubernetes Agent：

pipeline {
    agent {
        kubernetes {
            label 'jenkins-agent'
        }
    }
    stages {
        stage('Test Kubernetes Agent') {
            steps {
                sh 'echo "Hello from Kubernetes!"'
                sh 'kubectl get nodes || true'
            }
        }
    }
}

运行这个任务，如果一切正常，Jenkins会在Kubernetes集群中动态创建一个Pod来执行构建任务。

五、实战示例：完整的Java应用CI/CD Pipeline

让我们通过一个完整的示例，展示如何使用Jenkins和Kubernetes为Java应用构建CI/CD流程。

5.1 创建Jenkinsfile

在Java项目根目录创建Jenkinsfile：

pipeline {
    agent {
        kubernetes {
            label 'jenkins-java-agent'
            yaml """
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: jnlp
    image: jenkins/agent:latest
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
    - name: maven-cache
      mountPath: /root/.m2
  - name: docker
    image: docker:latest
    command: ["cat"]
    tty: true
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
  - name: maven
    image: maven:3.8.4-openjdk-11
    command: ["cat"]
    tty: true
    volumeMounts:
    - name: maven-cache
      mountPath: /root/.m2
  volumes:
  - name: docker-sock
    hostPath:
      path: /var/run/docker.sock
  - name: maven-cache
    emptyDir: {}
"""
        }
    }
    
    environment {
        REGISTRY = "your-registry.com/your-namespace"
        IMAGE_NAME = "your-java-app"
        KUBE_NAMESPACE = "devops-tools"
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Build and Test') {
            steps {
                container('maven') {
                    sh 'mvn clean compile test'
                }
            }
        }
        
        stage('Build Docker Image') {
            steps {
                container('docker') {
                    script {
                        def image = "${REGISTRY}/${IMAGE_NAME}:${env.BUILD_NUMBER}"
                        docker.build(image)
                    }
                }
            }
        }
        
        stage('Push Docker Image') {
            steps {
                container('docker') {
                    script {
                        def image = "${REGISTRY}/${IMAGE_NAME}:${env.BUILD_NUMBER}"
                        withCredentials([usernamePassword(
                            credentialsId: 'docker-registry-creds',
                            usernameVariable: 'REGISTRY_USER',
                            passwordVariable: 'REGISTRY_PASSWORD'
                        )]) {
                            sh "echo $REGISTRY_PASSWORD | docker login -u $REGISTRY_USER --password-stdin $REGISTRY"
                            sh "docker push $image"
                        }
                    }
                }
            }
        }
        
        stage('Deploy to Kubernetes') {
            steps {
                container('docker') {
                    script {
                        def image = "${REGISTRY}/${IMAGE_NAME}:${env.BUILD_NUMBER}"
                        sh """
                            sed -i 's|IMAGE_PLACEHOLDER|${image}|g' k8s-deployment.yaml
                            kubectl apply -f k8s-deployment.yaml -n ${KUBE_NAMESPACE}
                        """
                    }
                }
            }
        }
    }
    
    post {
        always {
            container('docker') {
                sh 'docker logout $REGISTRY'
            }
        }
        success {
            emailevent (
                subject: "SUCCESS: Job ${env.JOB_NAME} - Build ${env.BUILD_NUMBER}",
                body: "构建成功！应用已部署到Kubernetes。\n\n查看构建：${env.BUILD_URL}"
            )
        }
        failure {
            emailevent (
                subject: "FAILED: Job ${env.JOB_NAME} - Build ${env.BUILD_NUMBER}",
                body: "构建失败！请检查日志。\n\n查看构建：${env.BUILD_URL}"
            )
        }
    }
}

5.2 创建Kubernetes部署文件

在项目中创建k8s-deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: java-app
    spec:
      containers:
      - name: java-app
        image: IMAGE_PLACEHOLDER
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: java-app-service
spec:
  selector:
    app: java-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

六、高级技巧与最佳实践

为了让你的Jenkins和Kubernetes集成更加稳固高效，这里有一些高级技巧和最佳实践。

6.1 资源管理与优化

合理的资源管理可以防止构建任务耗尽集群资源：

apiVersion: v1
kind: ConfigMap
metadata:
  name: jenkins-agent-resources
data:
  pod-template.yaml: |
    apiVersion: v1
    kind: Pod
    spec:
      containers:
      - name: jnlp
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"
      - name: maven
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1"

6.2 缓存策略优化

利用持久化存储缓存依赖，大幅加速构建过程：

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: maven-cache-pvc
  namespace: devops-tools
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
---
# 在Pod模板中使用
spec:
  volumes:
  - name: maven-cache
    persistentVolumeClaim:
      claimName: maven-cache-pvc

6.3 安全最佳实践

使用最小权限原则：不要给Jenkins ServiceAccount过宽的权限
** secrets管理**：使用Kubernetes Secrets或HashiCorp Vault管理敏感信息
** 镜像安全**：定期扫描镜像漏洞，使用可信的基础镜像

七、故障排除：遇到问题怎么办？

即使配置再完美，也难免会遇到问题。这里有一些常见问题和解决方法。

7.1 Jenkins无法连接Kubernetes API

症状：在Jenkins中测试Kubernetes连接失败

解决：

检查Kubernetes API服务器URL是否正确
验证服务账户权限配置
查看Pod日志获取详细错误信息

7.2 Agent Pod无法启动

症状：构建任务一直处于挂起状态，没有Agent创建

解决：

检查资源配额是否足够
验证Pod模板配置是否正确
查看Kubernetes事件日志：kubectl get events -n devops-tools

7.3 构建速度慢

症状：每次构建都需要下载依赖，耗时较长

解决：

配置持久化缓存（如上面提到的Maven缓存）
使用本地镜像仓库
优化Dockerfile，合理利用分层缓存

结语：拥抱云原生，让CI/CD飞得更高

Jenkins与Kubernetes的集成，就像是给传统的CI/CD流程装上了涡轮增压发动机。通过动态创建构建Agent，我们不仅实现了资源的极致利用，还获得了前所未有的弹性扩展能力。

这种组合让我们能够真正实践"基础设施即代码"的理念，将整个CI/CD环境定义为可版本控制的配置。无论你的团队规模是10人还是1000人，这种架构都能从容应对。

云原生时代已经到来，是时候让你的CI/CD流程也跟上脚步了。从今天开始，尝试将Jenkins迁移到Kubernetes，体验高效、可靠、弹性的自动化流程带来的快感吧！

附录：常用命令速查

# 查看Jenkins Pod状态
kubectl get pods -n devops-tools

# 查看Jenkins日志
kubectl logs -f deployment/jenkins -n devops-tools

# 获取Jenkins访问地址
kubectl get svc -n devops-tools

# 重启Jenkins部署
kubectl rollout restart deployment/jenkins -n devops-tools

# 查看PersistentVolume状态
kubectl get pv

# 查看PersistentVolumeClaim状态
kubectl get pvc -n devops-tools