⚡

AzurePipelines生成器 azure-pipelines-generator

全面的 Azure DevOps 管道生成工具，遵循最佳实践和安全标准，用于 CI/CD 工作流和部署管道的创建与优化。

CI/CD 0 次安装 0 次浏览 更新于 3/4/2026

Azure Pipelines 生成器

概览

生成遵循当前最佳实践、安全标准和命名约定的生产就绪 Azure DevOps Pipeline 配置。在创建新的 Azure Pipelines、实施 CI/CD 工作流或构建部署管道时，请使用此技能。

核心能力

1. 生成基本 CI 管道

创建用于构建和测试应用程序的简单持续集成管道。

何时使用：

  • 用户请求：“为…创建 Azure 管道”，“构建 CI 管道…”，“生成 Azure DevOps 管道…”
  • 场景：持续集成、自动化构建、自动化测试

流程：

  1. 理解用户需求（语言、框架、测试需求）
  2. 确定触发器、池/代理要求和构建步骤
  3. 参考 docs/yaml-schema.md 了解 YAML 结构
  4. 参考 docs/best-practices.md 实施模式
  5. 参考 docs/tasks-reference.md 了解常见任务
  6. 生成遵循以下原则的管道：
    • 使用特定 vmImage 版本（而不是 ‘latest’）
    • 将任务版本固定到主版本（例如，@2）
    • 为所有阶段、作业和重要步骤使用 displayName
    • 为包管理器实现缓存
    • 添加适当的测试结果发布
    • 适当使用条件
    • 设置合理的超时时间
  7. 始终验证 使用 devops-skills:azure-pipelines-validator 技能生成的管道
  8. 如果验证失败，修复问题并重新验证

示例结构：

trigger:
  branches:
    include:
    - main
    - develop

pool:
  vmImage: 'ubuntu-22.04'

variables:
  buildConfiguration: 'Release'

steps:
- task: NodeTool@0
  displayName: '安装 Node.js'
  inputs:
    versionSpec: '20.x'

- task: Cache@2
  displayName: '缓存 npm 包'
  inputs:
    key: 'npm | "$(Agent.OS)" | package-lock.json'
    path: $(Pipeline.Workspace)/.npm

- script: npm ci --cache $(Pipeline.Workspace)/.npm
  displayName: '安装依赖项'

- script: npm run build
  displayName: '构建应用程序'

- script: npm test
  displayName: '运行测试'

- task: PublishTestResults@2
  condition: succeededOrFailed()
  inputs:
    testResultsFormat: 'JUnit'
    testResultsFiles: '**/test-results.xml'

2. 生成多阶段 CI/CD 管道

创建具有多个阶段的复杂管道，用于构建、测试和部署。

何时使用：

  • 用户请求：“创建完整的 CI/CD 管道…”，“构建多阶段管道…”，“部署到多个环境…”
  • 场景：完整的 CI/CD 工作流、多环境部署、复杂的构建过程

流程：

  1. 确定所需的所有阶段（构建、测试、部署）
  2. 确定阶段依赖关系和条件
  3. 计划部署策略和环境
  4. 使用 docs/yaml-schema.md 了解阶段/作业/步骤层次结构
  5. 参考 examples/multi-stage-cicd.yml 了解模式
  6. 生成管道：
    • 清晰的阶段组织
    • 适当的 dependsOn 关系
    • 用于环境跟踪的部署作业
    • 分支特定部署的条件
    • 阶段之间的工件管理
  7. 始终验证 使用 devops-skills:azure-pipelines-validator 技能

示例：

stages:
- stage: Build
  displayName: '构建阶段'
  jobs:
  - job: BuildJob
    displayName: '构建应用程序'
    pool:
      vmImage: 'ubuntu-22.04'
    steps:
    - script: npm run build
      displayName: '构建'
    - publish: $(Build.SourcesDirectory)/dist
      artifact: drop

- stage: Test
  displayName: '测试阶段'
  dependsOn: Build
  jobs:
  - job: TestJob
    displayName: '运行测试'
    steps:
    - script: npm test
      displayName: '测试'

- stage: DeployProd
  displayName: '部署到生产环境'
  dependsOn: Test
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployProd
    environment: production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying"

3. 生成 Docker 构建管道

创建用于构建和推送 Docker 镜像到容器注册表的管道。

何时使用：

  • 用户请求：“构建 Docker 镜像…”，“推送到容器注册表…”，“创建 Docker 管道…”
  • 场景：容器构建、注册表推送、多阶段 Docker 构建

流程：

  1. 确定 Docker 注册表（ACR、Docker Hub 等）
  2. 确定镜像命名和标记策略
  3. 如有需要，计划安全扫描
  4. 参考 docs/tasks-reference.md 了解 Docker@2 任务
  5. 参考 examples/kubernetes-deploy.yml 了解 Docker 构建模式
  6. 生成管道：
    • Docker@2 任务用于构建和推送
    • 注册表身份验证的服务连接
    • 适当的镜像标记（构建 ID、latest、语义版本）
    • 可选的安全扫描，使用 Trivy 或类似工具
  7. 始终验证 使用 devops-skills:azure-pipelines-validator 技能

示例：

variables:
  dockerRegistryServiceConnection: 'myACR'
  imageRepository: 'myapp'
  containerRegistry: 'myregistry.azurecr.io'
  tag: '$(Build.BuildId)'

steps:
- task: Docker@2
  displayName: '构建和推送'
  inputs:
    command: buildAndPush
    repository: $(imageRepository)
    dockerfile: '$(Build.SourcesDirectory)/Dockerfile'
    containerRegistry: $(dockerRegistryServiceConnection)
    tags: |
      $(tag)
      latest

4. 生成 Kubernetes 部署管道

创建部署应用程序到 Kubernetes 集群的管道。

何时使用：

  • 用户请求：“部署到 Kubernetes…”，“创建 K8s 部署管道…”，“部署到 AKS…”
  • 场景：Kubernetes 部署、AKS 部署、清单部署

流程：

  1. 确定 Kubernetes 部署方法（kubectl、Helm、清单）
  2. 确定集群连接详情
  3. 计划命名空间和环境策略
  4. 参考 docs/tasks-reference.md 了解 Kubernetes 任务
  5. 参考 examples/kubernetes-deploy.yml 了解模式
  6. 生成管道：
    • KubernetesManifest@0 或 Kubernetes@1 任务
    • 集群身份验证的服务连接
    • 适当的命名空间管理
    • 滚动状态检查
    • 健康检查验证
  7. 始终验证 使用 devops-skills:azure-pipelines-validator 技能

示例：

- task: KubernetesManifest@0
  displayName: '部署到 Kubernetes'
  inputs:
    action: 'deploy'
    kubernetesServiceConnection: 'myK8sCluster'
    namespace: 'production'
    manifests: |
      k8s/deployment.yml
      k8s/service.yml
    containers: '$(containerRegistry)/$(imageRepository):$(tag)'

5. 生成特定语言的管道

创建针对特定编程语言和框架优化的管道。

支持的语言：

  • .NET/C#：DotNetCoreCLI@2 任务，NuGet 还原，测试，发布
  • Node.js：NodeTool@0，Npm@1 任务，npm ci，构建，测试
  • Python：UsePythonVersion@0，pip install，pytest
  • Java：Maven@3 或 Gradle@2 任务
  • Go：GoTool@0 用于版本管理，go build/test 命令，模块缓存
  • Docker：多阶段构建，层缓存

流程：

  1. 确定编程语言和框架
  2. 参考 docs/tasks-reference.md 了解特定语言的任务
  3. 参考特定语言的示例（dotnet-cicd.yml，python-cicd.yml，go-cicd.yml）
  4. 生成管道：
    • 语言/运行时设置任务
    • 包管理器缓存
    • 特定于框架的构建命令
    • 带有适当报告的测试执行
    • 工件发布
  5. 始终验证 使用 devops-skills:azure-pipelines-validator 技能

Go 语言管道详情

Go 的任务：

  • GoTool@0：安装特定 Go 版本（注意：@0 是当前/唯一的主版本）
  • Cache@2：从 $(GOPATH)/pkg/mod 缓存 Go 模块
  • 脚本步骤：用于 go build，go test，go vet，go mod download

Go 模块缓存模式：

- task: Cache@2
  displayName: '缓存 Go 模块'
  inputs:
    key: 'go | "$(Agent.OS)" | go.sum'
    restoreKeys: |
      go | "$(Agent.OS)"
    path: $(GOPATH)/pkg/mod

Go 构建命令：

# 下载依赖项
- script: go mod download
  displayName: '下载 Go 模块'

# 运行 linting/vetting
- script: go vet ./...
  displayName: '运行 Go vet'

# 运行测试并包含覆盖率
- script: go test -v -race -coverprofile=coverage.out -covermode=atomic ./...
  displayName: '运行 Go 测试并包含覆盖率'

# 为 Linux 构建（常用于容器）
- script: |
    CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o $(Build.ArtifactStagingDirectory)/app ./cmd/server
  displayName: '为 Linux 构建 Go 二进制文件'

Go 矩阵测试示例：

strategy:
  matrix:
    go121:
      goVersion: '1.21'
    go122:
      goVersion: '1.22'
  maxParallel: 2

steps:
- task: GoTool@0
  displayName: '安装 Go $(goVersion)'
  inputs:
    version: $(goVersion)

- script: go test -v ./...
  displayName: '运行测试'

参考： 请参阅 examples/go-cicd.yml 以获取完整的 Go CI/CD 管道示例。

6. 生成基于模板的管道

创建可重用的模板和使用它们的管道。

何时使用：

  • 用户请求：“创建可重用模板…”，“为…使用模板”，“构建模块化管道…”
  • 场景：模板库，DRY 配置，共享 CI/CD 逻辑

流程：

  1. 确定要提取的共同模式
  2. 设计模板参数
  3. 参考 docs/templates-guide.md 了解模板语法
  4. 参考 examples/templates/ 了解模板模式
  5. 生成模板：
    • 清晰的参数定义，带有类型和默认值
    • 文档注释
    • 使用 ${{ }} 语法正确使用参数
    • 根据需要使用条件逻辑和迭代
  6. 生成使用模板的主管道
  7. 始终验证 模板和主管道

示例：

# 模板：templates/build.yml
parameters:
- name: nodeVersion
  type: string
  default: '20.x'

steps:
- task: NodeTool@0
  inputs:
    versionSpec: ${{ parameters.nodeVersion }}
- script: npm ci
- script: npm run build

# 主管道
steps:
- template: templates/build.yml
  parameters:
    nodeVersion: '20.x'

7. 处理 Azure 管道任务和文档查找

当生成使用特定 Azure 管道任务或需要最新文档的管道时：

检测：

  • 用户提到特定任务（例如，“DotNetCoreCLI”，“Docker”，“AzureWebApp”）
  • 用户请求与 Azure 服务集成
  • 管道需要特定的 Azure DevOps 功能

流程：

  1. 始终首先检查本地文档（必需）： 本地文档足以应对大多数常见任务，应作为您的主要参考：

    • docs/tasks-reference.md - 包含 .NET、Node.js、Python、Go、Docker、Kubernetes、Azure 任务
    • docs/yaml-schema.md - 完整的 YAML 语法参考
    • docs/best-practices.md - 安全、性能、命名模式

    大多数管道可以使用仅本地文档生成。 外部查找仅在以下情况下需要：

    • 未在本地文档中记录的任务（罕见的 Azure 服务、第三方市场任务）
    • 特定版本兼容性问题
    • 特定错误消息的故障排除

  2. 阅读相关示例文件（推荐）： 在生成之前，阅读与用户请求匹配的示例文件：

    • Go 管道？→ 阅读 examples/go-cicd.yml
    • Docker/K8s？→ 阅读 examples/kubernetes-deploy.yml
    • 多阶段？→ 阅读 examples/multi-stage-cicd.yml
    • 模板？→ 阅读 examples/template-usage.yml

这确保了一致的模式和最佳实践。

  1. 对于本地文档中没有的任务，使用外部来源：

    选项 A - Context7 MCP（首选，如果可用）：

    • 尝试使用 mcp__context7__resolve-library-id 解析库 ID
    • 查询：“azure-pipelines” 或 “azure-devops”
    • 使用 mcp__context7__get-library-docs 获取文档
    • Context7 提供结构化、版本感知的文档
    • 最适合：复杂任务、多个输入选项、详细示例

    选项 B - WebSearch（后备或特定查询）：

    搜索查询模式："[TaskName] Azure Pipelines 任务文档"
示例：
- "AzureWebApp@1 Azure Pipelines 任务文档"
- "KubernetesManifest@0 Azure Pipelines"
- "Docker@2 Azure Pipelines 任务最新版本"
    • 最适合：快速查找、特定版本信息、故障排除

    何时使用哪个：

    • 使用 Context7 首先获取全面的任务文档
    • 当 Context7 缺少特定任务时，使用 WebSearch 进行故障排除或快速版本检查
    • 任何方法都是可以接受的 - 目标是准确、最新的信息

  2. 分析文档以获取：

    • 任务名称和版本（例如，Docker@2）
    • 必需与可选输入
    • 输入类型和有效值
    • 如果有的话，任务输出
    • 最佳实践和示例
    • 服务连接要求

  3. 使用发现的信息生成管道：

    • 使用正确的任务名称和版本
    • 包括所有必需的输入
    • 使用适当的输入类型
    • 添加注释以解释任务目的
    • 如有需要，添加服务连接

  4. 包括有用的注释：

    # Docker@2：构建并推送 Docker 镜像到容器注册表
# 需要：Docker 注册表服务连接
- task: Docker@2
  displayName: '构建并推送 Docker 镜像'
  inputs:
    command: buildAndPush
    repository: myapp
    dockerfile: Dockerfile
    containerRegistry: myDockerRegistry

示例，包括任务文档查找：

# 任务：AzureFunctionApp@1
# 目的：部署到 Azure Functions
# 服务连接：Azure 资源管理器
- task: AzureFunctionApp@1
  displayName: '部署 Azure 函数'
  inputs:
    azureSubscription: 'AzureServiceConnection'  # 必需：ARM 服务连接
    appType: 'functionAppLinux'                  # Linux 函数应用
    appName: 'myfunctionapp'                     # 函数应用名称
    package: '$(Build.ArtifactStagingDirectory)/**/*.zip'  # 部署包
    runtimeStack: 'NODE|20'                      # Node.js 20 运行时

验证工作流

至关重要： 每个生成的 Azure Pipeline 配置都必须在呈现给用户之前进行验证。

验证流程

  1. 生成任何管道配置后，立即调用 devops-skills:azure-pipelines-validator 技能：

    Skill: devops-skills:azure-pipelines-validator

  2. devops-skills:azure-pipelines-validator 技能将：

    • 验证 YAML 语法
    • 检查 Azure Pipelines 架构合规性
    • 验证任务名称和版本
    • 检查最佳实践违规情况
    • 执行安全扫描（硬编码的秘密等）
    • 报告任何错误、警告或建议

  3. 如果验证失败：

    • 分析报告的错误
    • 修复生成配置中的问题
    • 如有需要，重新验证

  4. 如果验证成功：

    • 向用户展示验证后的配置
    • 提及验证成功
    • 提供使用说明

何时跳过验证

仅在以下情况下跳过验证：

  • 生成部分代码片段（不是完整文件）
  • 为文档目的创建示例
  • 用户明确请求跳过验证

强制执行的最佳实践

参考 docs/best-practices.md 了解全面的指导方针。关键原则：

强制性标准

  1. 安全第一：

    • 永远不要硬编码秘密或凭据
    • 使用服务连接连接外部服务
    • 在 Azure DevOps 中将敏感变量标记为秘密
    • 使用特定的 vmImage 版本（而不是 ‘latest’）
    • Docker 镜像标记策略：
      • 当 推送 镜像时：使用构建特定的标签作为主标签（例如，$(Build.BuildId)），可选地添加 :latest 以方便
      • 当 拉取/部署 镜像时：始终使用特定标签，生产部署中永远不要拉取 :latest
      • 示例：使用 $(tag) 和 latest 推送，但使用 $(containerRegistry)/$(imageRepository):$(tag) 部署

  2. 版本固定：

    • 使用特定的 vmImage 版本：ubuntu-22.04 而不是 ubuntu-latest
    • 将任务固定到主版本：Docker@2 而不是 Docker@0
    • 指定语言/运行时版本：Node.js 的 '20.x'
    • 关于 @0 版本的注释： 一些任务只有 @0 作为其当前/最新主版本（例如，GoTool@0，NodeTool@0，KubernetesManifest@0）。对于这些任务使用 @0 是正确和可接受的 - 目标是使用最新可用的主版本，而不是特别避免 @0。

  3. 性能：

    • 为包管理器实现缓存（Cache@2 任务）
    • 使用显式 dependsOn 进行并行执行
    • 设置工件过期
    • 在不需要完整历史记录时使用浅克隆
    • 优化矩阵策略

  4. 命名：

    • 阶段：PascalCase（例如，BuildAndTest，DeployProduction）
    • 作业：PascalCase（例如，BuildJob，TestJob）
    • displayName：句子情况（例如，'构建应用程序'，'运行测试'）
    • 变量：camelCase 或 snake_case（保持一致）

  5. 组织：

    • 使用阶段构建复杂管道
    • 使用部署作业跟踪环境
    • 使用模板重用逻辑
    • 使用变量组管理环境特定变量
    • 为复杂逻辑添加注释

  6. 错误处理：

    • 为长时间运行的作业设置 timeoutInMinutes
    • 适当使用条件（succeeded()，failed()，always()）
    • 对非关键步骤使用 continueOnError
    • 使用 condition: succeededOrFailed() 发布测试结果

  7. 测试：

    • 始终发布测试结果（PublishTestResults@2）
    • 发布代码覆盖率（PublishCodeCoverageResults@1）
    • 将 linting 作为单独的作业或步骤运行
    • 包括依赖项的安全扫描

资源

文档（按需加载）

  • docs/yaml-schema.md - 完整的 Azure Pipelines YAML 语法参考

    • 管道结构、阶段、作业、步骤
    • 触发器、池、变量、参数
    • 条件和表达式
    • 使用此： 用于 YAML 语法和结构

  • docs/tasks-reference.md - 常见 Azure Pipelines 任务目录

    • .NET、Node.js、Python、Docker、Kubernetes 任务
    • 任务输入、输出和示例
    • 服务连接要求
    • 使用此： 当选择要使用的任务时

  • docs/best-practices.md - Azure Pipelines 最佳实践

    • 安全模式、性能优化
    • 管道设计、错误处理
    • 常见模式和反模式
    • 使用此： 实施任何管道时

  • docs/templates-guide.md - 模板和可重用性指南

    • 模板类型（步骤、作业、阶段、变量）
    • 参数定义和使用
    • 模板表达式和迭代
    • 使用此： 创建可重用模板

示例（参考模式）

重要： 生成管道时，显式阅读 相关示例文件以确保一致的模式和最佳实践。使用阅读工具在生成之前加载这些文件。

示例文件 何时阅读
examples/basic-ci.yml 简单的 CI 管道，单阶段构建
examples/multi-stage-cicd.yml 多环境部署，复杂工作流
examples/kubernetes-deploy.yml Docker + K8s 部署，容器构建
examples/go-cicd.yml Go/Golang 应用程序
examples/dotnet-cicd.yml .NET/C# 应用程序
examples/python-cicd.yml Python 应用程序
examples/template-usage.yml 基于模板的管道
examples/templates/build-template.yml 创建可重用的构建模板
examples/templates/deploy-template.yml 创建可重用的部署模板

示例阅读工作流：

1. 用户请求："为 Go CI/CD 管道创建 Docker"
2. 阅读：examples/go-cicd.yml（Go 模式）
3. 阅读：examples/kubernetes-deploy.yml（Docker/K8s 模式）
4. 结合两种模式生成管道
5. 使用 devops-skills:azure-pipelines-validator 技能验证

典型工作流示例

用户请求： “为 Node.js 应用程序创建 CI/CD 管道，使用 Docker 部署到 AKS”

流程：

  1. ✅ 理解需求：

    • Node.js 应用程序
    • 构建和测试代码
    • 构建 Docker 镜像
    • 推送到容器注册表
    • 部署到 Azure Kubernetes Service
    • 多个环境（暂存、生产）

  2. ✅ 参考资源：

    • 检查 docs/yaml-schema.md 了解多阶段结构
    • 检查 docs/tasks-reference.md 了解 NodeTool、Docker、Kubernetes 任务
    • 检查 docs/best-practices.md 了解管道模式
    • 查看 examples/multi-stage-cicd.yml 和 examples/kubernetes-deploy.yml

  3. ✅ 搜索最新任务文档：

    • WebSearch：“Docker@2 Azure Pipelines 任务”
    • WebSearch：“KubernetesManifest@0 Azure Pipelines”
    • Context7（如果可用）：查询 azure-pipelines 库

  4. ✅ 生成管道：

    • 第一阶段：构建 Node.js 应用程序
      • NodeTool@0 用于 Node.js 设置
      • 带有缓存的 npm ci
      • npm run build 和测试
      • 发布测试结果
    • 第二阶段：构建 Docker 镜像
      • Docker@2 buildAndPush
      • 使用 Build.BuildId 和 latest 标记
    • 第三阶段：部署到 AKS
      • 带有环境的部署作业
      • KubernetesManifest@0 用于部署
      • 健康检查验证

  5. ✅ 验证：

    • 调用 devops-skills:azure-pipelines-validator 技能
    • 解决任何报告的问题
    • 如有需要，重新验证

  6. ✅ 呈现给用户：

    • 显示验证后的管道
    • 解释每个阶段
    • 提供设置说明（服务连接、环境）
    • 提及验证成功

常见管道模式

基本三阶段模式

stages:
- stage: Build
  jobs:
  - job: BuildJob
    steps:
    - script: echo "构建"

- stage: Test
  dependsOn: Build
  jobs:
  - job: TestJob
    steps:
    - script: echo "测试"

- stage: Deploy
  dependsOn: Test
  jobs:
  - deployment: DeployJob
    environment: production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "部署"

矩阵测试模式

strategy:
  matrix:
    node18:
      nodeVersion: '18.x'
    node20:
      nodeVersion: '20.x'
    node22:
      nodeVersion: '22.x'
  maxParallel: 3

steps:
- task: NodeTool@0
  inputs:
    versionSpec: $(nodeVersion)
- script: npm test

条件部署模式

- stage: DeployProd
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployProd
    environment: production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "部署"

错误消息和故障排除

如果 devops-skills:azure-pipelines-validator 报告错误：

  1. 语法错误： 修复 YAML 格式、缩进或结构
  2. 任务版本错误： 确保任务使用正确的版本格式（TaskName@version）
  3. 池/vmImage 错误： 使用特定的 vmImage 版本，而不是 ‘latest’
  4. 阶段/作业错误： 验证阶段包含作业，作业包含步骤
  5. 安全警告： 解决硬编码的秘密、:latest 标签

如果找不到特定任务的文档：

  1. 尝试替代搜索查询
  2. 直接检查 Microsoft Learn：https://learn.microsoft.com/azure/devops/pipelines/tasks/reference/
  3. 检查 GitHub：https://github.com/microsoft/azure-pipelines-tasks
  4. 询问用户是否有特定任务版本要求

总结

生成 Azure 管道时始终遵循此顺序：

  1. 理解 - 澄清用户需求、语言、部署目标
  2. 参考 - 检查 docs/yaml-schema.md、tasks-reference.md、best-practices.md
  3. 搜索 - 对于特定任务，使用 WebSearch 或 Context7 获取当前文档
  4. 生成 - 遵循标准（固定、缓存、命名、阶段）
  5. 验证 - 始终使用 devops-skills:azure-pipelines-validator 技能
  6. 修复 - 解决任何验证错误
  7. 呈现 - 提供验证过、生产就绪的管道

生成 Azure 管道，使其：

  • ✅ 安全，正确管理秘密和版本固定
  • ✅ 遵循当前最佳实践和约定
  • ✅ 使用适当的 YAML 结构和层次结构
  • ✅ 针对性能优化（缓存、并行化）
  • ✅ 有文档记录，带有 displayName 和注释
  • ✅ 经过验证并合规
  • ✅ 生产就绪且可维护