Jenkins Pipeline¶

# === Docker 方式安装（推荐） ===
docker run -d \
  --name jenkins \                           # 容器名
  -p 8080:8080 \                             # Web 界面端口
  -p 50000:50000 \                           # Agent 通信端口
  -v jenkins_home:/var/jenkins_home \        # 数据持久化
  jenkins/jenkins:lts-jdk17                  # 使用 LTS 版本 + JDK17

# === Ubuntu 直接安装 ===
# 添加 Jenkins 仓库密钥
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee \
  /usr/share/keyrings/jenkins-keyring.asc > /dev/null  # 导入 GPG 密钥

# 添加 apt 仓库
echo "deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
  https://pkg.jenkins.io/debian-stable binary/" | sudo tee \
  /etc/apt/sources.list.d/jenkins.list > /dev/null  # 添加源

sudo apt update && sudo apt install jenkins  # 安装 Jenkins
sudo systemctl start jenkins  # 启动 Jenkins
sudo systemctl enable jenkins  # 设置开机自启

# 获取初始管理员密码
sudo cat /var/lib/jenkins/secrets/initialAdminPassword  # 复制这个密码去浏览器输入

// Jenkinsfile（放在项目根目录）
pipeline {
    agent any  // 在任意可用节点运行

    environment {  // 环境变量
        APP_NAME = 'my-app'  // 应用名
        DEPLOY_ENV = 'production'  // 部署环境
    }

    stages {
        stage('Checkout') {  // 阶段1：拉取代码
            steps {
                checkout scm  // 从 SCM（Git）拉取代码
            }
        }

        stage('Build') {  // 阶段2：构建
            steps {
                sh 'pip install -r requirements.txt'  // 安装依赖
                sh 'python setup.py build'  // 构建
            }
        }

        stage('Test') {  // 阶段3：测试
            steps {
                sh 'pytest --junitxml=report.xml'  // 运行测试并输出 JUnit 格式报告
            }
            post {
                always {  // 无论成功失败都执行
                    junit 'report.xml'  // 发布测试报告
                }
            }
        }

        stage('Deploy') {  // 阶段4：部署
            when {
                branch 'main'  // 只在 main 分支执行
            }
            steps {
                sh './deploy.sh'  // 执行部署脚本
            }
        }
    }

    post {  // 流水线结束后
        success {
            echo 'Pipeline succeeded!'  // 成功时打印
        }
        failure {
            echo 'Pipeline failed!'  // 失败时打印
        }
    }
}

pipeline {
    agent any

    parameters {  // 定义参数（在 Jenkins UI 中可以填写）
        string(name: 'BRANCH', defaultValue: 'main', description: '要构建的分支')
        choice(name: 'ENV', choices: ['dev', 'staging', 'prod'], description: '部署环境')
        booleanParam(name: 'SKIP_TEST', defaultValue: false, description: '是否跳过测试')
    }

    stages {
        stage('Build') {
            steps {
                echo "Building branch: ${params.BRANCH}"  // 使用参数
            }
        }

        stage('Test') {
            when {
                expression { !params.SKIP_TEST }  // 条件：没选跳过测试才执行
            }
            steps {
                sh 'pytest'
            }
        }

        stage('Deploy') {
            steps {
                echo "Deploying to ${params.ENV}"  // 部署到选定环境
            }
        }
    }
}

pipeline {
    agent any

    stages {
        stage('Parallel Tests') {  // 并行测试
            parallel {  // parallel 块内的阶段并行执行
                stage('Unit Tests') {
                    steps {
                        sh 'pytest tests/unit/'  // 单元测试
                    }
                }
                stage('Integration Tests') {
                    steps {
                        sh 'pytest tests/integration/'  // 集成测试
                    }
                }
                stage('Lint') {
                    steps {
                        sh 'ruff check .'  // 代码检查
                    }
                }
            }
        }
    }
}

pipeline {
    agent {
        docker {
            image 'python:3.12-slim'  // 在 Docker 容器中运行
            args '-v /tmp:/tmp'  // 挂载卷
        }
    }

    stages {
        stage('Test') {
            steps {
                sh 'python --version'  // 容器内执行
                sh 'pip install pytest && pytest'
            }
        }
    }
}

pipeline {
    agent any

    stages {
        stage('Deploy') {
            steps {
                withCredentials([  // 从 Jenkins 凭据库读取
                    usernamePassword(
                        credentialsId: 'docker-hub',  // 凭据 ID
                        usernameVariable: 'DOCKER_USER',  // 用户名存入变量
                        passwordVariable: 'DOCKER_PASS'   // 密码存入变量
                    )
                ]) {
                    sh 'docker login -u $DOCKER_USER -p $DOCKER_PASS'  // 使用凭据
                    sh 'docker push myapp:latest'
                }
            }
        }
    }
}

// vars/buildPython.groovy（共享库中的自定义步骤）
def call(String version = '3.12') {  // 定义可调用的函数
    pipeline {
        agent { docker { image "python:${version}" } }
        stages {
            stage('Install') {
                steps { sh 'pip install -r requirements.txt' }
            }
            stage('Test') {
                steps { sh 'pytest' }
            }
        }
    }
}

// Jenkinsfile 中使用
@Library('my-shared-lib') _  // 加载共享库
buildPython('3.12')  // 调用共享库中的步骤

// === Pipeline 结构 ===
pipeline { agent any; stages { stage('X') { steps { sh 'cmd' } } } }

// === Agent 类型 ===
agent any                    // 任意节点
agent none                   // 不分配（每个 stage 自己指定）
agent { label 'linux' }      // 指定标签的节点
agent { docker { image 'python:3.12' } }  // Docker 容器

// === 条件执行 ===
when { branch 'main' }       // 指定分支
when { tag pattern: "v\\d+.*" }  // Tag 匹配模式
when { expression { return env.BUILD == 'true' } }  // 表达式
when { changeset "src/**" }  // 文件变更

// === 后处理 ===
post {
    always { ... }           // 总是执行
    success { ... }          // 成功时
    failure { ... }          // 失败时
    changed { ... }          // 状态变化时（如从失败变成功）
    cleanup { ... }          // 最后清理
}

// === 常用步骤 ===
sh 'command'                 // 执行 Shell 命令
bat 'command'                // 执行 Windows 命令
echo 'message'               // 打印信息
checkout scm                 // 拉取代码
junit 'report.xml'           // 发布测试报告
archiveArtifacts 'dist/**'   // 归档产物
input message: '继续?'        // 人工审批
timeout(time: 30, unit: 'MINUTES') { ... }  // 超时控制
retry(3) { ... }             // 失败重试